@tetacom/ng-components 1.7.1 → 1.7.3

package/types/tetacom-ng-components.d.ts

@@ -0,0 +1,3600 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnInit, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, NgZone, Renderer2, ViewContainerRef, RendererFactory2, ViewRef, ComponentRef, ComponentFactoryResolver, ApplicationRef, Type, Injector, AfterContentChecked, QueryList, Signal, PipeTransform, Provider, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, ReplaySubject, BehaviorSubject, MonoTypeOperatorFunction } from 'rxjs';
+import * as THREE from 'three';
+import { ControlValueAccessor, FormControl, FormGroup, ValidatorFn, ControlContainer, NgControl, UntypedFormGroup, AbstractControl, ValidationErrors, UntypedFormControl } from '@angular/forms';
+import * as i1 from '@angular/common';
+import { DatePipe } from '@angular/common';
+import { MaskitoOptions } from '@maskito/core';
+import { Dayjs } from 'dayjs';
+import { HttpBackend, HttpClient } from '@angular/common/http';
+import * as i2 from '@jsverse/transloco';
+import { TranslocoService } from '@jsverse/transloco';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+
+declare class AccordionComponent {
+    readonly accordionClassName = true;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "teta-accordion", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class AccordionContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionContentDirective, "[tetaAccordionContent]", never, {}, {}, never, never, true, never>;
+}
+
+type viewType = 'brick' | 'rounded' | 'circle';
+
+declare class AccordionItemComponent {
+    accordion: AccordionComponent;
+    private cdr$;
+    content?: AccordionContentDirective;
+    open: boolean;
+    disabled: boolean;
+    readonly accordionItemClass = true;
+    divider: boolean;
+    get dividerClass(): boolean;
+    viewType: viewType;
+    get class(): string;
+    private readonly accordion$;
+    constructor();
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "teta-accordion-item", never, { "open": { "alias": "open"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; }, {}, ["content"], ["teta-accordion-head"], true, never>;
+}
+
+declare class AccordionHeadComponent implements OnInit {
+    accordionItem: AccordionItemComponent;
+    readonly accordionHeadClass = true;
+    showToggle: boolean;
+    private readonly accordionItem$;
+    constructor();
+    toggle(): void;
+    get open(): boolean;
+    get disabled(): boolean;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionHeadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionHeadComponent, "teta-accordion-head", never, { "showToggle": { "alias": "showToggle"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare enum AvatarColorEnum {
+    vibrant = 0,
+    nebula = 1,
+    gorgonzola = 2,
+    lagoon = 3,
+    lime = 4,
+    pumpkin = 5,
+    vanity = 6,
+    navy = 7,
+    turquoise = 8,
+    greyish = 9,
+    heart = 10,
+    gloomy = 11,
+    rockman = 12,
+    hair = 13,
+    cerise = 14,
+    iris = 15,
+    caribbean = 16,
+    poisonous = 17
+}
+
+declare class AvatarComponent implements OnInit {
+    photo?: string | ArrayBuffer;
+    name?: string;
+    id?: number;
+    viewType?: viewType;
+    size?: '24' | '28' | '32' | '44' | '64' | '128' | '200';
+    get avatar(): string;
+    colorMap: Map<AvatarColorEnum, string>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "teta-avatar", never, { "photo": { "alias": "photo"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AutocompleteComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteComponent, "teta-autocomplete", never, {}, {}, never, never, true, never>;
+}
+
+declare enum TetaSize {
+    XS = 0,
+    S = 1,
+    M = 2,
+    L = 3,
+    XL = 4
+}
+
+type ButtonViewType = 'primary' | 'outline' | 'ghost';
+declare class ButtonComponent {
+    palette: string;
+    class: any;
+    view: ButtonViewType;
+    square: boolean;
+    viewType: viewType;
+    size: TetaSize;
+    private get getClass();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[teta-button], teta-button", never, { "palette": { "alias": "palette"; "required": false; }; "class": { "alias": "class"; "required": false; }; "view": { "alias": "view"; "required": false; }; "square": { "alias": "square"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface Base3dPoint {
+    x: number;
+    y: number;
+    z: number;
+    md?: number;
+}
+
+declare class Series3d<T extends Base3dPoint> {
+    name?: string;
+    color?: string;
+    points: T[];
+    constructor(options?: {
+        name?: string;
+        color?: string;
+        points: T[];
+    });
+}
+
+declare class Chart3dOptions {
+    axes?: {
+        min?: number;
+        max?: number;
+    };
+    unit?: string;
+    series: Series3d<Base3dPoint>[];
+    constructor(options?: Chart3dOptions);
+}
+
+declare class ThemeSwitchService {
+    theme: Observable<boolean>;
+    private theme$;
+    constructor();
+    switchTheme(): void;
+    saveTheme(value: boolean): void;
+    restoreTheme(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeSwitchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeSwitchService>;
+}
+
+interface WellMeshData {
+    mesh: THREE.Mesh;
+    series: Series3d<Base3dPoint>;
+    scale: {
+        x: any;
+        y: any;
+        z: any;
+    };
+    curve: THREE.CatmullRomCurve3;
+    points: Base3dPoint[];
+}
+interface IntersectionResult {
+    wellData: WellMeshData;
+    intersectionPoint: THREE.Vector3;
+    closestCurvePoint: THREE.Vector3;
+    closestDataPoint: Base3dPoint;
+    md: number;
+    tvd: number;
+}
+
+declare class Chart3dTooltipService {
+    private _raycaster;
+    private _mouse;
+    findClosestPointOnCurveLocal(point: THREE.Vector3, curve: THREE.CatmullRomCurve3): THREE.Vector3;
+    constructor();
+    findIntersection(event: MouseEvent, canvas: HTMLCanvasElement, camera: THREE.Camera, wellMeshes: WellMeshData[]): IntersectionResult | null;
+    private findClosestPointOnCurveToRay;
+    private findClosestDataPoint;
+    private calculateTVD;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Chart3dTooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Chart3dTooltipService>;
+}
+
+declare class Chart3dComponent implements OnInit, AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _themeService;
+    private _cdr;
+    private _tooltipService;
+    canvasRef: ElementRef;
+    tooltipRef: ElementRef;
+    private _scene;
+    private _camera;
+    private _renderer;
+    private _controls;
+    private _obs;
+    private _config;
+    private _animationFrameId;
+    private SIDE_SIZE;
+    private gridColor;
+    private axesColor;
+    private _alive;
+    tooltipVisible: boolean;
+    tooltipX: number;
+    tooltipY: number;
+    tooltipWellName: string;
+    tooltipMD: string;
+    tooltipTVD: string;
+    tooltipUnit: string;
+    private _wellMeshes;
+    private _tooltipMarker;
+    private _mouseMoveHandler;
+    private _mouseLeaveHandler;
+    constructor(_elementRef: ElementRef, _themeService: ThemeSwitchService, _cdr: ChangeDetectorRef, _tooltipService: Chart3dTooltipService);
+    set config(config: Chart3dOptions);
+    get config(): Chart3dOptions;
+    private get canvas();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private init;
+    private createScene;
+    private setSize;
+    private render;
+    private startRenderingLoop;
+    private addResizeObserver;
+    private removeResizeObserver;
+    private makeSprite;
+    private drawTicks;
+    private getScales;
+    private addMouseMoveListener;
+    private handleMouseMove;
+    private showTooltip;
+    private hideTooltip;
+    private removeMouseListeners;
+    private disposeThreeResources;
+    private updateTooltipMarker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Chart3dComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Chart3dComponent, "teta-chart3d", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const CHECKBOX_CONTROL_VALUE_ACCESSOR: any;
+declare class CheckboxComponent implements ControlValueAccessor, OnInit {
+    private cdr;
+    tabindex: number;
+    class: any;
+    private get getClass();
+    palette: string;
+    noLabel: boolean;
+    /**
+     * компонент неактивен
+     */
+    disabled: boolean;
+    /**
+     * true/false или list
+     */
+    value: any;
+    /**
+     * true/false или list
+     */
+    binary: boolean;
+    labelPosition: 'left' | 'right';
+    allowNull: boolean;
+    checked: boolean;
+    /**
+     * Значение
+     */
+    private model$;
+    get model(): any;
+    set model(v: any);
+    constructor(cdr: ChangeDetectorRef);
+    changeValue(): void;
+    writeValue(model: any): void;
+    isChecked(): boolean;
+    removeValue(): void;
+    addValue(): void;
+    ngOnInit(): void;
+    onChange(_: any): void;
+    onTouched(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "teta-checkbox", never, { "class": { "alias": "class"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "noLabel": { "alias": "noLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "binary": { "alias": "binary"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare enum Align {
+    left = 0,
+    right = 1,
+    center = 2,
+    auto = 3,
+    fitWidth = 4,
+    minWidth = 5,
+    outerLeft = 6,
+    outerRight = 7,
+    outerAuto = 8
+}
+
+declare enum VerticalAlign {
+    top = 0,
+    bottom = 1,
+    center = 2,
+    auto = 3,
+    innerTop = 4,
+    innerBottom = 5,
+    innerAuto = 6
+}
+
+interface DateFromToModel {
+    from: Date | string | number;
+    to: Date | string | number;
+}
+
+interface TetaLocalisation {
+    apply: string;
+    cancel: string;
+    clear: string;
+    dateRangeMask: string;
+    dateMask: string;
+    dateTimeMask: string;
+    pin: string;
+    unpin: string;
+    sortAsc: string;
+    sortDesc: string;
+    clearSort: string;
+    clearAllSort: string;
+    clearFilter: string;
+    clearAllFilters: string;
+    autosizeColumn: string;
+    autosizeAll: string;
+    resetColumnsSize: string;
+    from: string;
+    to: string;
+    all: string;
+    min: string;
+    max: string;
+    sum: string;
+    avg: string;
+    search: string;
+    selectYear: string;
+    selected: string;
+    notFound: string;
+    notSelected: string;
+    yes: string;
+    no: string;
+    months: [string, string, string, string, string, string, string, string, string, string, string, string];
+    days: [string, string, string, string, string, string, string];
+    daysShort: [string, string, string, string, string, string, string];
+}
+
+declare class TetaConfigService {
+    private defaultLocale;
+    private locale$;
+    locale: rxjs.Observable<TetaLocalisation>;
+    constructor();
+    setLocale(newLocale: TetaLocalisation): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TetaConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TetaConfigService>;
+}
+
+declare abstract class BasePicker {
+    protected _elementRef: ElementRef<any>;
+    protected _cdr: ChangeDetectorRef;
+    protected datePipe: DatePipe;
+    protected localeService: TetaConfigService;
+    abstract mask: string;
+    abstract date: any;
+    abstract locale: Observable<TetaLocalisation>;
+    abstract showTime: boolean;
+    abstract minDate: Date | string | number;
+    abstract maxDate: Date | string | number;
+    abstract invalid: boolean;
+    abstract disabled: boolean;
+    abstract align: Align;
+    abstract verticalAlign: VerticalAlign;
+    abstract viewType: viewType;
+    abstract appendToBody: boolean;
+    abstract backdrop: boolean;
+    abstract allowNull: boolean;
+    abstract input: ElementRef;
+    abstract selectDate: EventEmitter<Date> | EventEmitter<DateFromToModel>;
+    open: boolean;
+    abstract selectedDate: ReplaySubject<any>;
+    placeholder: string;
+    inputText: string;
+    maskitoOptions: MaskitoOptions;
+    protected constructor();
+    abstract onChange(date: Date): any;
+    abstract prepareInput(): any;
+    abstract onBlur(): any;
+    abstract setDate(date: any): any;
+    changeInput(v: any): void;
+    changePlaceholder(value: string): void;
+    openChange(e: boolean): void;
+    checkNull(): string;
+    openPicker: (show: boolean) => void;
+    changeSelectedDate(date: any, selectedDate?: any): void;
+    emitValue(value: any): void;
+    isValueChange(value: any): boolean;
+    checkEnter(e: any): void;
+    isAvailableLength(val: string, length: number): boolean;
+    getDateFromStr(str: string, separator?: string): {
+        day: number;
+        month: number;
+        year: number;
+    };
+    getTimeFromStr(str: string, separator?: string): {
+        hours: number;
+        mins: number;
+    };
+    focus(): void;
+    getLocaleString(date: Date | number | string): string;
+    getAvailableDate(min: Date | number | string, max: Date | number | string, date: Date | number | string): Date;
+}
+
+declare class DatePeriod {
+    start: Date;
+    end: Date;
+    constructor(start: Date, end: Date);
+}
+
+declare const DATE_PICKER_CONTROL_VALUE_ACCESSOR: any;
+declare class DatePickerComponent extends BasePicker implements OnInit, ControlValueAccessor, OnChanges {
+    date: Date | string | number;
+    locale: Observable<TetaLocalisation>;
+    showTime: boolean;
+    minDate: Date | string | number;
+    maxDate: Date | string | number;
+    invalid: boolean;
+    disabled: boolean;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    viewType: viewType;
+    appendToBody: boolean;
+    backdrop: boolean;
+    allowNull: boolean;
+    open: boolean;
+    firstDayOfWeek: number;
+    disabledDates: Date[];
+    disabledPeriods: DatePeriod[];
+    disabledDays: number[];
+    minYearDate: Date;
+    maxYearDate: Date;
+    input: ElementRef;
+    selectDate: EventEmitter<Date>;
+    selectedDate: ReplaySubject<Date | string | number>;
+    mask: string;
+    readonly classDatepicker = true;
+    get dateTimeClass(): boolean;
+    readonly tabindex = 0;
+    constructor();
+    ngOnInit(): void;
+    prepareInput(isFirstRender?: boolean): Promise<void>;
+    onBlur(event?: FocusEvent): void;
+    setDate(date: any): void;
+    onChange(date: Date): void;
+    registerOnChange(fn: (date: Date) => any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(obj: Date | string | number): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    changeInput(v: any): void;
+    private updateCalendarSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerComponent, "teta-date-picker", never, { "date": { "alias": "date"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "open": { "alias": "open"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledPeriods": { "alias": "disabledPeriods"; "required": false; }; "disabledDays": { "alias": "disabledDays"; "required": false; }; "minYearDate": { "alias": "minYearDate"; "required": false; }; "maxYearDate": { "alias": "maxYearDate"; "required": false; }; }, { "selectDate": "selectDate"; }, never, never, true, never>;
+}
+
+declare class DayModel {
+    disabled: boolean;
+    isCurrentMonth: boolean;
+    today: boolean;
+    selected: boolean;
+    date: Date;
+    weekend: boolean;
+    constructor(options?: {
+        disabled?: boolean;
+        isCurrentMonth?: boolean;
+        today?: boolean;
+        selected?: boolean;
+        date: Date;
+        weekend?: boolean;
+    });
+}
+
+interface MinMaxDateModel {
+    min: Date | string | number;
+    max: Date | string | number;
+}
+
+declare abstract class BaseCalendar implements OnChanges, OnDestroy {
+    protected _cdr: ChangeDetectorRef;
+    abstract selectedDate: any;
+    abstract locale: TetaLocalisation;
+    abstract open: boolean;
+    abstract viewType: viewType;
+    abstract min: Date | string | number;
+    abstract isDateNull: boolean;
+    abstract max: Date | string | number;
+    abstract setDate: EventEmitter<Date>;
+    currentMonth: ReplaySubject<number>;
+    minMax: ReplaySubject<MinMaxDateModel>;
+    currentYear: ReplaySubject<number>;
+    selectedPicker: BehaviorSubject<'day' | 'month' | 'year'>;
+    abstract calendar: DayModel[] | {
+        currentMonth: DayModel[];
+        nextMonth: DayModel[];
+    };
+    alive: boolean;
+    protected constructor(_cdr: ChangeDetectorRef);
+    generateCalendar(selectedDate: Dayjs, year: number, month: number, minMax: MinMaxDateModel): DayModel[];
+    isSuitableMinDate(d: Date, minDate: Date | string | number): boolean;
+    isSuitableMaxDate(d: Date, maxDate: Date | string | number): boolean;
+    isSelected(date: Date, selectedDate: Date): boolean;
+    ngOnDestroy(): void;
+    selectPicker(entity: 'day' | 'month' | 'year'): void;
+    selectMonth(month: number): void;
+    selectYear(year: number): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    changeCalendarData(selectedDate: Date | number | string): void;
+    setYear(year: number): void;
+    changeMonth(month: number, year: number): void;
+    getAvailableMonthYear(month: number, year: number): {
+        availableMonth: number;
+        availableYear: number;
+    };
+    getMothName(month: number): string;
+    selectDate(date: Date): void;
+    scrollMonth: (e: any, month: number, year: number) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCalendar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseCalendar, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class DateCalendarComponent extends BaseCalendar implements OnChanges, OnDestroy {
+    _cdr: ChangeDetectorRef;
+    selectedDate: Date | string | number;
+    open: boolean;
+    locale: TetaLocalisation;
+    viewType: viewType;
+    min: Date | string | number;
+    isDateNull: boolean;
+    max: Date | string | number;
+    setDate: EventEmitter<Date>;
+    calendar: DayModel[];
+    constructor(_cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateCalendarComponent, "teta-date-calendar", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "open": { "alias": "open"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "min": { "alias": "min"; "required": false; }; "isDateNull": { "alias": "isDateNull"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "setDate": "setDate"; }, never, never, true, never>;
+}
+
+declare const DATE_Range_CONTROL_VALUE_ACCESSOR: any;
+declare class DateRangeComponent extends BasePicker implements OnInit, ControlValueAccessor {
+    date: DateFromToModel;
+    locale: Observable<TetaLocalisation>;
+    showTime: boolean;
+    minDate: Date | string | number;
+    maxDate: Date | string | number;
+    invalid: boolean;
+    disabled: boolean;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    viewType: viewType;
+    appendToBody: boolean;
+    backdrop: boolean;
+    allowNull: boolean;
+    input: ElementRef;
+    selectDate: EventEmitter<DateFromToModel>;
+    mask: string;
+    selectedDate: ReplaySubject<DateFromToModel>;
+    readonly classDaterange = true;
+    constructor();
+    changeSelectedDate(date: Date, selectedDate: DateFromToModel): void;
+    checkNull(): string;
+    prepareInput(): Promise<void>;
+    onBlur(): void;
+    setDate(range: DateFromToModel): void;
+    writeValue(obj: DateFromToModel): void;
+    isValueChange(value: any): boolean;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    ngOnInit(): void;
+    onChange(date: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeComponent, "teta-date-range", never, { "date": { "alias": "date"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; }, { "selectDate": "selectDate"; }, never, never, true, never>;
+}
+
+declare class RangeCalendarComponent extends BaseCalendar implements OnChanges, OnDestroy {
+    _cdr: ChangeDetectorRef;
+    locale: TetaLocalisation;
+    open: boolean;
+    date: DateFromToModel;
+    viewType: viewType;
+    allowNull: boolean;
+    selectedDate: DateFromToModel;
+    min: Date | string | number;
+    isDateNull: boolean;
+    max: Date | string | number;
+    hoveredDateChange: EventEmitter<Date>;
+    setDate: EventEmitter<Date>;
+    calendar: {
+        currentMonth: DayModel[];
+        nextMonth: DayModel[];
+    };
+    _hoveredDate: Date;
+    get hoveredDate(): Date;
+    set hoveredDate(e: Date);
+    constructor(_cdr: ChangeDetectorRef);
+    getFromTo(): {
+        from: any;
+        to: any;
+    };
+    isSelected(d: Date, selectedDate: Date): boolean;
+    checkSelected(date: Date, selectedDate: Date): boolean;
+    isFirstDaySuitable(m: number, y: number, max: string | number | Date): boolean;
+    isLastDaySuitable(m: number, y: number, min: string | number | Date): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RangeCalendarComponent, "teta-range-calendar", never, { "locale": { "alias": "locale"; "required": false; }; "open": { "alias": "open"; "required": false; }; "date": { "alias": "date"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "min": { "alias": "min"; "required": false; }; "isDateNull": { "alias": "isDateNull"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "hoveredDateChange": "hoveredDateChange"; "setDate": "setDate"; }, never, never, true, never>;
+}
+
+declare enum DatePickerMode {
+    date = 0,
+    month = 1,
+    year = 2
+}
+
+declare class DelimiterComponent implements OnInit {
+    direction: 'vertical' | 'horizontal';
+    palette: string;
+    height: number;
+    verticalMargin: number;
+    horizontalMargin: number;
+    class: any;
+    private get getClass();
+    private get getHeight();
+    private get getWidth();
+    private get getMargin();
+    constructor();
+    getBgColor(): string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DelimiterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DelimiterComponent, "teta-delimiter", never, { "direction": { "alias": "direction"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "height": { "alias": "height"; "required": false; }; "verticalMargin": { "alias": "verticalMargin"; "required": false; }; "horizontalMargin": { "alias": "horizontalMargin"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type AutoCloseIgnoreCase = 'esc' | 'enter' | 'inside' | 'outside';
+
+declare class DropdownContentDirective {
+    private _elementRef;
+    nativeElement: HTMLElement;
+    constructor(_elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownContentDirective, "[tetaDropdownContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DropdownBase {
+    protected _cdr: ChangeDetectorRef;
+    protected _document: any;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _zone: NgZone;
+    protected _renderer: Renderer2;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    appendToBody: boolean;
+    disabled: boolean;
+    backdrop: boolean;
+    className: string | string[];
+    viewType: viewType;
+    set open(val: boolean);
+    get open(): boolean;
+    get container(): any;
+    openChange: EventEmitter<boolean>;
+    autoClose: boolean;
+    autoCloseIgnore: Array<AutoCloseIgnoreCase>;
+    protected _head: ElementRef;
+    protected _content: DropdownContentDirective;
+    protected _body: HTMLElement | null;
+    protected _backdrop: HTMLElement | null;
+    protected _open: boolean;
+    protected _alive: boolean;
+    constructor(_cdr: ChangeDetectorRef, _document: any, _elementRef: ElementRef<HTMLElement>, _zone: NgZone, _renderer: Renderer2);
+    click(event: MouseEvent): void;
+    documentClick(event: MouseEvent): void;
+    keyUp(event: KeyboardEvent): void;
+    protected addScrollListener(): void;
+    protected removeScrollListener(): void;
+    private scrollListener;
+    protected closeDropdown(): void;
+    private openDropdown;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownBase, never, never, { "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "className": { "alias": "className"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "open": { "alias": "open"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "autoCloseIgnore": { "alias": "autoCloseIgnore"; "required": false; }; }, { "openChange": "openChange"; }, ["_head", "_content"], never, true, never>;
+}
+
+declare class DropdownComponent extends DropdownBase implements OnInit, OnDestroy {
+    protected _cdr: ChangeDetectorRef;
+    protected _document: any;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _zone: NgZone;
+    protected _renderer: Renderer2;
+    constructor(_cdr: ChangeDetectorRef, _document: any, _elementRef: ElementRef<HTMLElement>, _zone: NgZone, _renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "teta-dropdown", ["dropdown"], {}, {}, never, ["[tetaDropdownHead]"], true, never>;
+}
+
+declare class DropdownHeadDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownHeadDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownHeadDirective, "[tetaDropdownHead]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DropdownDirective extends DropdownBase implements OnInit, OnDestroy, AfterViewInit {
+    protected _cdr: ChangeDetectorRef;
+    protected _document: any;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _zone: NgZone;
+    protected _renderer: Renderer2;
+    constructor(_cdr: ChangeDetectorRef, _document: any, _elementRef: ElementRef<HTMLElement>, _zone: NgZone, _renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownDirective, "[tetaDropdown]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PopupContentComponent implements OnInit, OnDestroy {
+    dialog: boolean;
+    className: string | string[];
+    private get getClass();
+    constructor();
+    addClass(className: string): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopupContentComponent, "teta-popup-content", never, { "className": { "alias": "className"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ExpandCardComponent implements OnInit {
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    showCross: boolean;
+    crossClick: EventEmitter<MouseEvent>;
+    constructor();
+    ngOnInit(): void;
+    setOpen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandCardComponent, "teta-expand-card", ["expand-card"], { "open": { "alias": "open"; "required": false; }; "showCross": { "alias": "showCross"; "required": false; }; }, { "openChange": "openChange"; "crossClick": "crossClick"; }, never, ["head", "*"], true, never>;
+}
+
+declare class ExpandItemComponent {
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    setOpen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandItemComponent, "teta-expand-item", ["expand-item"], { "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["head", "*"], true, never>;
+}
+
+declare class ExpandPanelContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandPanelContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpandPanelContentDirective, "[tetaExpandPanelContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ExpandPanelHeadDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandPanelHeadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpandPanelHeadDirective, "[tetaExpandPanelHead]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ExpandPanelComponent implements OnInit {
+    content: ExpandPanelContentDirective;
+    head: ExpandPanelHeadDirective;
+    placeholder: string;
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    cookieName: string;
+    direction: 'left' | 'right';
+    constructor();
+    openPanel(): void;
+    closePanel(): void;
+    ngOnInit(): void;
+    private saveCookie;
+    private restoreCookie;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandPanelComponent, "teta-expand-panel", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "open": { "alias": "open"; "required": false; }; "cookieName": { "alias": "cookieName"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, { "openChange": "openChange"; }, ["content", "head"], never, true, never>;
+}
+
+declare class FileUploadAreaComponent {
+    fileUpload: boolean;
+    get fileUploadActive(): boolean;
+    multiple: boolean;
+    disabled: boolean;
+    accept: string[];
+    upload: EventEmitter<FileList>;
+    input?: ElementRef;
+    buttonTemplate?: TemplateRef<any>;
+    files: any;
+    private _asActive;
+    dragEnter(event: DragEvent): void;
+    dragOver(event: DragEvent): void;
+    dragLeave(event: DragEvent): void;
+    drop(event: DragEvent): void;
+    fileChanged(event: any): void;
+    private preventDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadAreaComponent, "teta-file-upload-area", never, { "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; }, { "upload": "upload"; }, ["buttonTemplate"], ["*"], true, never>;
+}
+
+declare class FileItemComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileItemComponent, "teta-file-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class DateFilterValue {
+    /**
+     * Значение должно быть меньше чем
+     */
+    lessThan: Date | undefined | null;
+    /**
+     * Значение должно быть больше чем
+     */
+    greaterThan: Date | undefined | null;
+    constructor(options?: {
+        lessThan?: Date | undefined | null;
+        greaterThan?: Date | undefined | null;
+    });
+}
+
+interface IFilter<T> {
+    name: string;
+    field: string;
+    value: T;
+}
+
+declare class FilterBase<T> implements IFilter<T> {
+    field: string;
+    name: string;
+    value: T;
+    constructor(options?: {
+        field: string;
+        name: string;
+    });
+}
+
+declare class DateFilter extends FilterBase<DateFilterValue> {
+    constructor(options?: {
+        value?: DateFilterValue;
+        field: string;
+        name: string;
+    });
+}
+
+declare enum StringFilterType {
+    /**
+     * Строгое совпадение
+     */
+    Equals = 1,
+    /**
+     * Начинается с указанной подстроки
+     */
+    StartsWith = 2,
+    /**
+     * Оканчивается указанной подстрокой
+     */
+    EndsWith = 3,
+    /**
+     * Содержит указанную подстроку
+     */
+    Contains = 4
+}
+
+declare class StringFilter extends FilterBase<string> {
+    type: StringFilterType;
+    constructor(options?: {
+        value?: string;
+        type?: StringFilterType;
+        field: string;
+        name: string;
+    });
+}
+
+declare class NumericFilterValue {
+    /**
+     * Значение должно быть меньше чем
+     */
+    lessThan: number | null | undefined;
+    /**
+     * Значение должно быть больше чем
+     */
+    greaterThan: number | null | undefined;
+    /**
+     * Значение должно быть равно
+     */
+    equalsTo: number | null | undefined;
+    constructor(options?: {
+        lessThan?: number | null | undefined;
+        greaterThan?: number | null | undefined;
+        equalsTo?: number | null | undefined;
+    });
+}
+
+declare class NumericFilter extends FilterBase<NumericFilterValue> {
+    strict: boolean;
+    constructor(options?: {
+        value?: NumericFilterValue;
+        strict?: boolean;
+        field: string;
+        name: string;
+    });
+}
+
+declare enum ListFilterType {
+    None = 0,
+    Excluded = 1
+}
+
+declare class ListFilter extends FilterBase<any[]> {
+    type: ListFilterType;
+    constructor(options?: {
+        value?: any[];
+        type?: ListFilterType;
+        field: string;
+        name: string;
+    });
+}
+
+declare class SortParam {
+    /**
+     * Поле сортировки
+     */
+    field: string;
+    /**
+     * Направление (true: Asc, false: Desc)
+     */
+    asc: boolean;
+    /**
+     * Порядок сортировки
+     */
+    order: number;
+    /**
+     * Инициализация из анонимного объекта
+     */
+    constructor(options?: {
+        field?: string;
+        asc?: boolean;
+        order?: number;
+    });
+}
+
+declare class BooleanFilter extends FilterBase<boolean> {
+    constructor(options?: {
+        value?: boolean;
+        field: string;
+        name: string;
+    });
+}
+
+declare class FilterState {
+    stringFilters: StringFilter[];
+    numericFilters: NumericFilter[];
+    dateFilters: DateFilter[];
+    listFilters: ListFilter[];
+    booleanFilters: BooleanFilter[];
+    sortParams: SortParam[];
+    constructor(options?: {
+        stringFilters?: any[];
+        booleanFilters?: any[];
+        numericFilters?: any[];
+        dateFilters?: any[];
+        listFilters?: any[];
+        sortParams?: any[];
+    });
+    static restore(cookie: string): any;
+    save(cookieName: string): void;
+    addListFilter(value: ListFilter): ListFilter;
+    addDateFilter(value: DateFilter): DateFilter;
+    addStringFilter(value: StringFilter): StringFilter;
+    addBooleanFilter(value: BooleanFilter): BooleanFilter;
+    addNumericFilter(value: NumericFilter): NumericFilter;
+    clear(): void;
+}
+
+declare enum FilterType {
+    string = 0,
+    number = 1,
+    date = 2,
+    list = 3,
+    boolean = 4,
+    color = 5,
+    custom = 6
+}
+
+interface IFilterItemOptions {
+    sortOrder?: number;
+    name?: string;
+    caption?: string;
+    hint?: string;
+    sortable?: boolean;
+    sortField?: string;
+    filterable?: boolean;
+    filterField?: string;
+    filterType?: FilterType | null;
+    stringFilterType?: StringFilterType;
+    listFilterType?: ListFilterType;
+    strict?: boolean;
+    filterComponent?: any;
+    columns?: FilterItem[];
+}
+declare class FilterItem {
+    /**
+     * Порядковый номер
+     */
+    sortOrder: number;
+    /**
+     * Название столбца для заголовка таблицы
+     */
+    caption: string;
+    /**
+     * Подсказка
+     */
+    hint: string;
+    /**
+     * Название столбца в строке результатов
+     */
+    name: string;
+    /**
+     * Возможность сортировать поле
+     */
+    sortable: boolean;
+    /**
+     * Возможность фильтровать поле
+     */
+    filterable: boolean;
+    /**
+     * Поле для сортировки
+     */
+    sortField: string;
+    /**
+     * Поле для фильтрации
+     */
+    filterField: string;
+    /**
+     * Тип фильтра
+     */
+    filterType: FilterType | null;
+    /**
+     * Тип сравнения строкового фильтра
+     */
+    stringFilterType: StringFilterType;
+    /**
+     * Тип сравнения строкового фильтра
+     */
+    listFilterType: ListFilterType;
+    /**
+     * Строгое сравнение
+     */
+    strict: boolean;
+    /**
+     * Компонент для рендера фильтра
+     */
+    filterComponent: any;
+    /**
+     * Дочерние элементы
+     */
+    columns: FilterItem[];
+    constructor(options?: IFilterItemOptions);
+}
+
+interface IIdName<T> {
+    [key: string]: any;
+    id: T;
+    name: string;
+    parentId?: T;
+}
+
+declare abstract class FilterComponentBase<T> {
+    abstract column: FilterItem;
+    abstract state: FilterState;
+    abstract data: T[];
+    abstract filterOptions: IIdName<any>[];
+    abstract filterChanged: EventEmitter<IFilter<any>>;
+}
+
+declare class DateFilterComponent<T> extends FilterComponentBase<T> implements OnInit {
+    private changeDetector;
+    private _config;
+    column: FilterItem;
+    data: T[];
+    filterOptions: IIdName<any>[];
+    filterChanged: EventEmitter<FilterBase<DateFilterValue>>;
+    filter: DateFilter;
+    state$: FilterState;
+    set state(val: FilterState);
+    get state(): FilterState;
+    locale: Observable<TetaLocalisation>;
+    constructor(changeDetector: ChangeDetectorRef, _config: TetaConfigService);
+    ngOnInit(): void;
+    private getFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent<any>, "teta-date-filter", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class ListFilterComponent<T> extends FilterComponentBase<T> implements OnInit {
+    private changeDetector;
+    private _config;
+    column: FilterItem;
+    data: T[];
+    filterOptions: IIdName<any>[];
+    filterChanged: EventEmitter<FilterBase<any[]>>;
+    filter: ListFilter;
+    state$: FilterState;
+    search: string;
+    locale: Observable<TetaLocalisation>;
+    get visibleOptions(): IIdName<any>[];
+    set state(val: FilterState);
+    get state(): FilterState;
+    excluded: boolean;
+    constructor(changeDetector: ChangeDetectorRef, _config: TetaConfigService);
+    ngOnInit(): void;
+    all(): boolean;
+    setAll(value: boolean): void;
+    setType(): void;
+    setFilter(value: any[]): void;
+    private getFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListFilterComponent<any>, "teta-list-filter", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class NumericFilterComponent<T> extends FilterComponentBase<T> implements OnInit {
+    private changeDetector;
+    private _config;
+    column: FilterItem;
+    data: T[];
+    filterOptions: IIdName<any>[];
+    filterChanged: EventEmitter<FilterBase<NumericFilterValue>>;
+    filter: NumericFilter;
+    private state$;
+    set state(val: FilterState);
+    get state(): FilterState;
+    locale: Observable<TetaLocalisation>;
+    constructor(changeDetector: ChangeDetectorRef, _config: TetaConfigService);
+    ngOnInit(): void;
+    private getFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumericFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumericFilterComponent<any>, "teta-numeric-filter", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class StringFilterComponent<T> extends FilterComponentBase<T> implements OnInit {
+    private changeDetector;
+    private _config;
+    column: FilterItem;
+    data: T[];
+    filterOptions: IIdName<any>[];
+    filterChanged: EventEmitter<FilterBase<string>>;
+    filter: StringFilter;
+    state$: FilterState;
+    set state(val: FilterState);
+    get state(): FilterState;
+    locale: Observable<TetaLocalisation>;
+    constructor(changeDetector: ChangeDetectorRef, _config: TetaConfigService);
+    ngOnInit(): void;
+    setFilter(): void;
+    private getFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StringFilterComponent<any>, "teta-string-filter", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class BooleanFilterComponent<T> extends FilterComponentBase<T> implements OnInit {
+    private changeDetector;
+    private _config;
+    column: FilterItem;
+    data: T[];
+    filterOptions: IIdName<any>[];
+    filterChanged: EventEmitter<FilterBase<boolean>>;
+    filter: BooleanFilter;
+    state$: FilterState;
+    set state(val: FilterState);
+    get state(): FilterState;
+    locale: Observable<TetaLocalisation>;
+    constructor(changeDetector: ChangeDetectorRef, _config: TetaConfigService);
+    ngOnInit(): void;
+    setFilter(): void;
+    private getFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BooleanFilterComponent<any>, "teta-boolean-filter", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class FilterHostComponent<T> implements OnInit, OnDestroy {
+    private viewContainerRef;
+    set column(val: FilterItem);
+    set state(val: FilterState);
+    set data(data: T[]);
+    set filterOptions(val: IIdName<any>[]);
+    filterChanged: EventEmitter<FilterBase<any>>;
+    private _alive;
+    private _column;
+    private _state;
+    private _data;
+    private _filterOptions;
+    private _componentRef;
+    private _init;
+    constructor(viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterHostComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterHostComponent<any>, "teta-filter-host", never, { "column": { "alias": "column"; "required": false; }; "state": { "alias": "state"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare class IconService {
+    protected _document: any;
+    private _rendererFactory;
+    private _httpBackend;
+    private _http;
+    private static _loaded;
+    private static _pending;
+    private _renderer;
+    constructor(_document: any, _rendererFactory: RendererFactory2, _httpBackend: HttpBackend, _http: HttpClient);
+    addSprite(url: string, bypassInterceptors?: boolean): void;
+    private getSVG;
+    private svgElementFromString;
+    private cloneSVG;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
+}
+
+declare class IconSpriteDirective implements OnInit {
+    private _iconService;
+    tetaIconSprite: string | string[];
+    bypassInterceptors: boolean;
+    constructor(_iconService: IconService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconSpriteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconSpriteDirective, "[tetaIconSprite]", never, { "tetaIconSprite": { "alias": "tetaIconSprite"; "required": false; }; "bypassInterceptors": { "alias": "bypassInterceptors"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IconComponent {
+    name: string;
+    size: TetaSize;
+    palette: string;
+    class: any;
+    private get getClass();
+    getName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "teta-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IconFileComponent implements OnInit {
+    name: string;
+    class: any;
+    private get getClass();
+    constructor();
+    ngOnInit(): void;
+    getName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconFileComponent, "teta-icon-file", never, { "name": { "alias": "name"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ColorInputComponent implements ControlValueAccessor {
+    private _cdr;
+    private elementRef;
+    disabled: boolean;
+    input: ElementRef;
+    value: string;
+    constructor(_cdr: ChangeDetectorRef);
+    onFocus(): void;
+    emitBlur(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    writeValue(input: string): void;
+    onChange(input: string): void;
+    onTouched(): void;
+    getHexColor(color: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorInputComponent, "teta-color-input", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputComponent {
+    label?: string;
+    hint?: string;
+    viewType: viewType;
+    horizontal: boolean;
+    required: boolean;
+    get column(): boolean;
+    align: typeof Align;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "teta-input", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, ["*", "message"], true, never>;
+}
+
+declare class TextFieldComponent implements ControlValueAccessor {
+    private _cdr;
+    placeholder: string;
+    leftIconName?: string;
+    disabled: boolean;
+    onlyNumber: boolean;
+    decimalPart: number;
+    invalid: boolean;
+    input: ElementRef;
+    inputFocused: boolean;
+    readonly textField = true;
+    value: string;
+    onFocus(): void;
+    keyPress(event: KeyboardEvent): void;
+    emitBlur(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    writeValue(input: string): void;
+    onChange(input: string): void;
+    onTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextFieldComponent, "teta-text-field", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "leftIconName": { "alias": "leftIconName"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "onlyNumber": { "alias": "onlyNumber"; "required": false; }; "decimalPart": { "alias": "decimalPart"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormGroupTitleComponent {
+    readonly className = true;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupTitleComponent, "teta-form-group-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class Message {
+    name: string | null | undefined;
+    title: string | null | undefined;
+    text: string | null | undefined;
+    infinite: boolean;
+    viewType?: viewType;
+    duration: number;
+    className: string[] | null | undefined;
+    palette: string;
+    template: TemplateRef<any>;
+    constructor(options?: {
+        name?: string;
+        title: string;
+        text?: string;
+        infinite?: boolean;
+        duration?: number;
+        viewType?: viewType;
+        palette?: string;
+        className?: string[];
+        template?: TemplateRef<any>;
+    });
+}
+
+declare class MessageService {
+    message: Observable<Message>;
+    clear: Observable<string>;
+    private _message;
+    private _clear;
+    constructor();
+    add(message: Message): void;
+    addMultiple(messages: Message[]): void;
+    clearMessages(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}
+
+declare class MessageComponent implements AfterViewInit, OnDestroy {
+    message: Message;
+    index: number;
+    closed: EventEmitter<any>;
+    class: any;
+    private get getClass();
+    timeout: any;
+    constructor();
+    init(): void;
+    reset(): void;
+    closeMe(event: MouseEvent): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageComponent, "teta-message", never, { "message": { "alias": "message"; "required": false; }; "index": { "alias": "index"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class MessageHostComponent implements OnInit, OnDestroy {
+    private _svc;
+    private _cdr;
+    class: any;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    itemClose: EventEmitter<any>;
+    messages: Message[];
+    private readonly _alignMap;
+    private readonly _valignMap;
+    private get getClass();
+    private _alive;
+    constructor(_svc: MessageService, _cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    closedItem(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageHostComponent, "teta-message-host", never, { "class": { "alias": "class"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; }, { "itemClose": "itemClose"; }, never, never, true, never>;
+}
+
+interface IModalConfig {
+    backdrop?: boolean;
+    closeOnBackdropClick?: boolean;
+    resizable?: boolean;
+    draggable?: boolean;
+    class?: string[];
+    esc?: boolean;
+    beforeClose?: Observable<any>;
+    beforeOpen?: Observable<any>;
+}
+
+declare enum ModalCloseReason {
+    resolve = 0,
+    exit = 1,
+    backdrop = 2,
+    esc = 3
+}
+
+interface IModalResult<T = any> {
+    /**
+     * Любые другие данные которые пользователь желает вернуть при закрытии окна
+     */
+    [key: string]: any;
+    data?: T;
+    /**
+     * Причина закрытия окна
+     */
+    reason: ModalCloseReason;
+}
+
+declare class ModalContainerComponent {
+    private elRef$;
+    config: IModalConfig;
+    closeEvent: EventEmitter<IModalResult<any>>;
+    tabindex: number;
+    dialog: boolean;
+    get classList(): string;
+    constructor(elRef$: ElementRef);
+    keyup(event: KeyboardEvent): void;
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalContainerComponent, "teta-modal-container", never, { "config": { "alias": "config"; "required": false; }; }, { "closeEvent": "closeEvent"; }, never, ["*"], true, never>;
+}
+
+declare class CurrentModal {
+    close: (result?: IModalResult) => void;
+}
+
+interface DialogButtonType {
+    text: string;
+    palette?: string;
+    icon?: string;
+}
+interface DialogDataType {
+    title: string;
+    text?: string;
+    confirm?: DialogButtonType;
+    decline?: DialogButtonType;
+}
+
+declare class DialogComponent {
+    modal: CurrentModal;
+    title: string;
+    private _text;
+    get text(): string;
+    set text(value: string);
+    private _confirm;
+    get confirm(): DialogButtonType;
+    set confirm(value: DialogButtonType);
+    private _decline;
+    get decline(): null | DialogButtonType;
+    set decline(value: null | DialogButtonType);
+    constructor(modal: CurrentModal);
+    cancel(): void;
+    ok(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "teta-dialog", never, { "title": { "alias": "title"; "required": true; }; "text": { "alias": "text"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "decline": { "alias": "decline"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ModalModule, never, [typeof i1.CommonModule, typeof i2.TranslocoModule, typeof ModalContainerComponent, typeof DialogComponent], [typeof ModalContainerComponent, typeof DialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ModalModule>;
+}
+
+declare class TetaContentRef {
+    nodes: any[];
+    viewRef?: ViewRef;
+    componentRef?: ComponentRef<any>;
+    constructor(nodes: any[], viewRef?: ViewRef, componentRef?: ComponentRef<any>);
+}
+
+declare class ModalInstance<T = any> {
+    private _window;
+    private _content;
+    onClose: Observable<IModalResult<T>>;
+    private _onClose;
+    constructor(_window: ComponentRef<ModalContainerComponent>, _content: TetaContentRef);
+    get window(): ComponentRef<ModalContainerComponent>;
+    get component(): ComponentRef<any> | null;
+    close: (event?: IModalResult) => void;
+    private destroy;
+}
+
+declare class DynamicData {
+    [key: string]: any;
+    constructor(value: {
+        [key: string]: any;
+    });
+}
+
+declare class DynamicComponentService {
+    private _componentFactoryResolver;
+    private _rendererFactory;
+    private _appRef;
+    private _renderer;
+    constructor(_componentFactoryResolver: ComponentFactoryResolver, _rendererFactory: RendererFactory2, _appRef: ApplicationRef);
+    createComponent<T>(component: Type<T>, contentRef: TetaContentRef, injector: Injector, container: any): ComponentRef<T>;
+    createContent(content: string | TemplateRef<any> | Type<any> | null | undefined, injector: Injector, context?: any): TetaContentRef;
+    destroy<T>(component: ComponentRef<T> | null | undefined, content: TetaContentRef | null, container: HTMLElement): void;
+    getContext(content: string | TemplateRef<any> | Type<any> | null | undefined, context: any): any;
+    getInjector(data: DynamicData, parent: Injector): Injector;
+    private fromString;
+    private fromTemplate;
+    private fromComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentService>;
+}
+
+declare class ModalService {
+    private _document;
+    private _injector;
+    private _factory;
+    private _stack;
+    private _modalChanged;
+    private readonly _container;
+    constructor(_document: any, _injector: Injector, _factory: DynamicComponentService);
+    closeAll(): void;
+    create<T = any>(content: string | TemplateRef<any> | Type<any>, data?: any, config?: IModalConfig, injector?: Injector): ModalInstance<T>;
+    private getContext;
+    private getInjector;
+    private register;
+    private unregister;
+    private focus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
+}
+
+declare class DialogService {
+    private _modal;
+    constructor(_modal: ModalService);
+    alert(title: string): void;
+    confirm(confirmDialogData: DialogDataType): Observable<boolean>;
+    private createDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class PagerComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PagerComponent, "teta-pager", never, {}, {}, never, never, true, never>;
+}
+
+declare class PagerState {
+    /**
+     * Текущая страница
+     */
+    page: number;
+    /**
+     * Количество записей на странице
+     */
+    pageSize: number;
+    /**
+     * Количество страниц
+     */
+    count: number;
+    /**
+     * Количество записей
+     */
+    totalCount: number;
+    /**
+     * первая видимая страница
+     */
+    start: number;
+    /**
+     * Последняя видимая страница
+     */
+    end: number;
+    /**
+     * Список страниц
+     */
+    pages: number[];
+    /**
+     * Инициализация из анонимного объекта
+     */
+    constructor(options?: {
+        page?: number;
+        pageSize?: number;
+        count?: number;
+        totalCount?: number;
+    });
+    createPages(): void;
+}
+
+declare class PagerUtil {
+    static getPage<T>(data: T[], paging: PagerState): T[];
+}
+
+declare class PanelComponent implements OnInit {
+    width: number;
+    private get panel();
+    readonly column = true;
+    readonly auto = true;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PanelComponent, "teta-panel", never, { "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const SLIDER_CONTROL_VALUE_ACCESSOR: any;
+declare class ProgressBarComponent implements ControlValueAccessor {
+    private _elementRef;
+    private _renderer;
+    private _cdr;
+    private _document;
+    min: number;
+    max: number;
+    step: number;
+    private readonly slider;
+    readonly progressBar = true;
+    percent: number;
+    moving: boolean;
+    set value(value: number);
+    get value(): number;
+    get containerPosition(): {
+        min: any;
+        max: any;
+    };
+    private _value;
+    mouseup(): void;
+    click: (event: MouseEvent) => void;
+    onChange(_: any): void;
+    onTouched(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: number): void;
+    mousedown: () => void;
+    private mousemove;
+    private getMousePositionInPercents;
+    private setValue;
+    private getValueFromPercent;
+    private preventGlobalMouseEvents;
+    private restoreGlobalMouseEvents;
+    private addListener;
+    private removeListener;
+    private setPercentFromValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "teta-progress-bar", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IDictionary<T> {
+    [key: string]: T;
+}
+
+interface ICellCoordinates {
+    row: number;
+    column: string;
+}
+
+declare class TableRow<T> {
+    valid: boolean;
+    data: T;
+    constructor(options?: {
+        valid?: boolean;
+        data: T;
+    });
+}
+
+declare class ColumnResizeEvent {
+    column: TableColumn;
+    newWidth: number;
+    constructor(column: TableColumn, newWidth: number);
+}
+
+interface ICellEvent extends ICellCoordinates {
+    event: Event;
+}
+
+interface IColumnRow<T> {
+    row?: T;
+    column: TableColumn;
+}
+interface ICellInstance<T> {
+    row?: TableRow<T>;
+    column: TableColumn;
+}
+interface ICellInstanceEvent<T> extends ICellInstance<T> {
+    event: Event;
+}
+interface ICellInstanceValue<T> extends ICellInstance<T> {
+    value: any;
+}
+
+interface ICellValue extends ICellCoordinates {
+    value: any;
+}
+
+declare class SortEvent {
+    column: TableColumn;
+    shiftKey: boolean;
+    constructor(column: TableColumn, shiftKey: boolean);
+}
+
+declare class TableColumnStore {
+    width: number;
+    flex: number;
+    locked: boolean;
+    name: string;
+    columns: TableColumnStore[];
+    constructor(options?: {
+        width?: number;
+        flex?: number;
+        sortOrder?: number;
+        locked?: boolean;
+        name?: string;
+        columns?: any[];
+    });
+}
+
+declare enum EditEvent {
+    click = 0,
+    focus = 1,
+    doubleClick = 2
+}
+
+declare enum EditType {
+    none = 0,
+    cell = 1,
+    row = 2
+}
+
+declare enum SelectType {
+    none = 0,
+    checkBox = 1,
+    mouse = 2
+}
+
+declare class TableService<T> {
+    columns: Observable<TableColumn[]>;
+    displayData: Observable<TableRow<T>[]>;
+    dict: Observable<IDictionary<IIdName<any>[]>>;
+    filterOptions: Observable<IDictionary<IIdName<any>[]>>;
+    state: Observable<FilterState>;
+    selectType: SelectType;
+    editRowStart: Observable<ICellEvent | null>;
+    editRowStop: Observable<ICellCoordinates | null>;
+    editCellStart: Observable<ICellEvent | null>;
+    editCellStop: Observable<ICellCoordinates | null>;
+    valueChanged: Observable<ICellCoordinates | null>;
+    valueSet: Observable<ICellValue>;
+    stateChanged: Observable<FilterState>;
+    filterClear: Observable<TableColumn>;
+    selectedRows: Observable<T[]>;
+    activeRow: Observable<T | null>;
+    hiddenColumns: Observable<string[]>;
+    scrollIndex: Observable<number>;
+    editType: EditType;
+    editEvent: EditEvent;
+    rowEditable?: boolean | ((row: T) => boolean);
+    trackRow: (index: number, row: T) => any;
+    get dragSource(): TableColumn;
+    private initialColumnsHash;
+    private initialColumns;
+    private displayColumns;
+    private _columns;
+    private _hiddenColumns;
+    private _displayData;
+    private _dict;
+    private _filterOptions;
+    private _state;
+    private _cookieName?;
+    private _hiddenCookieName?;
+    private _columnsCookieName?;
+    private _editRowStart;
+    private _editRowStop;
+    private _editCellStart;
+    private _editCellStop;
+    private _valueChanged;
+    private _valueSet;
+    private _stateChanged;
+    private _filterClear;
+    private _dragSource?;
+    private _selectedRows;
+    private _activeRow;
+    private _scrollIndex;
+    private _currentEditCell?;
+    get currentEditCell(): ICellCoordinates;
+    constructor();
+    setData(data: T[]): void;
+    setDict(dict: IDictionary<IIdName<any>[]>): void;
+    setFilterOptions(filterOptions: IDictionary<IIdName<any>[]>): void;
+    setColumns(columns: TableColumn[]): void;
+    restoreDefaultColumns(): void;
+    updateColumns(columns: TableColumn[]): void;
+    saveColumnsState(): void;
+    clearColumnsState(): void;
+    setDisplayColumns(columns: TableColumn[]): void;
+    restoreColumns(): TableColumn[];
+    restoreColumnsState(columns: TableColumnStore[]): TableColumn[];
+    setState(state: FilterState): void;
+    setCookieName(name: string): void;
+    restoreState(): void;
+    saveHiddenColumns(hiddenColumns: string[]): void;
+    restoreHiddenColumns(): void;
+    sortAsc(sortEvent: SortEvent): void;
+    sortDesc(sortEvent: SortEvent): void;
+    clearSort(column: TableColumn): void;
+    clearAllSort(): void;
+    clearFilter(column: TableColumn): void;
+    clearAllFilters(): void;
+    pinColumn(column: TableColumn): void;
+    dragStart(column: TableColumn): void;
+    lockPreviousColumns(column: TableColumn, element: HTMLElement): void;
+    resizeColumn(event: ColumnResizeEvent): void;
+    autosizeColumn(column: TableColumn, target: HTMLElement): void;
+    autosizeAllColumns(target: HTMLElement): void;
+    reorderColumn(column: TableColumn, insertBefore: boolean): void;
+    getColumnParent(column: TableColumn): TableColumn;
+    startEditRow(cellEvent: ICellEvent): void;
+    startEditCell(cellEvent: ICellEvent): void;
+    setActiveRow(row: T): void;
+    selectRows(rows: T[]): void;
+    selectOrDeselectRow(row: T): void;
+    selectRange(row: T): void;
+    selectRow(row: T): void;
+    deselectRow(row: T): void;
+    selectAll(): void;
+    deselectAll(): void;
+    allRowsSelected(): boolean | null;
+    setHiddenColumns(value: string[]): void;
+    columnIsHidden(column: TableColumn): boolean;
+    changeValue(coordinates: ICellCoordinates): void;
+    setValue(cellValue: ICellValue): void;
+    setValue(cellValue: ICellInstanceValue<T>): void;
+    getRowByIndex(rowIndex?: number): TableRow<T> | undefined;
+    getRowIndex(row: T): number;
+    getEventCell(event: Event): HTMLElement | null;
+    getEventRow(event: Event): HTMLElement | null;
+    getNextEditableCell(coords: ICellCoordinates): ICellCoordinates | null;
+    getPreviousEditableCell(coords: ICellCoordinates): ICellCoordinates | null;
+    getNextCell(coords: ICellCoordinates): ICellCoordinates | null;
+    getPreviousCell(coords: ICellCoordinates): ICellCoordinates | null;
+    getNextRowCell(coords: ICellCoordinates): ICellCoordinates | null;
+    getPreviousRowCell(coords: ICellCoordinates): {
+        column: any;
+        row: number;
+    };
+    getColumnByName(columnName: string): any;
+    scrollToIndex(index: number): void;
+    getVisibleColumns(): any[];
+    getCellInstance(coords: ICellCoordinates): ICellInstance<T> | null;
+    private getFlatColumns;
+    private findParent;
+    private findParentColumn;
+    getTableElement(element: HTMLElement): Element;
+    private setColumnAutoWidth;
+    private clearValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableService<any>>;
+}
+
+declare abstract class CellComponentBase<T> implements OnInit, OnDestroy {
+    protected svc: TableService<T>;
+    protected cdr: ChangeDetectorRef;
+    private _formGroup;
+    readonly cellClass = true;
+    get cellInvalid(): boolean;
+    get control(): FormControl;
+    protected _column: TableColumn;
+    set column(column: TableColumn);
+    get column(): TableColumn;
+    protected _row: TableRow<T>;
+    set row(row: TableRow<T>);
+    get row(): TableRow<T>;
+    filterOptions: IIdName<any>[];
+    dict: IDictionary<IIdName<any>[]>;
+    get formGroup(): FormGroup;
+    protected _edit: boolean;
+    get edit(): boolean;
+    get editable(): boolean;
+    get index(): number;
+    protected _alive: boolean;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    private init;
+    abstract startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    abstract stopEdit(): void;
+    private setupControl;
+    private start;
+    private stop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellComponentBase<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CellComponentBase<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare enum AggregationType {
+    none = 0,
+    sum = 1,
+    avg = 2,
+    min = 3,
+    max = 4
+}
+
+interface HeadDropdownTabConfig {
+    strategy: 'merge' | 'replace';
+    tabs?: HeadDropdownTab[];
+}
+interface HeadDropdownTab {
+    title?: string;
+    icon?: string;
+    template?: TemplateRef<any>;
+    order?: number;
+    showTab: (column: TableColumn) => boolean;
+}
+
+interface ITableColumnOptions extends IFilterItemOptions {
+    width?: number;
+    flex?: number;
+    sortOrder?: number;
+    locked?: boolean;
+    name?: string;
+    parentName?: string;
+    caption?: string;
+    hint?: string;
+    unit?: string;
+    unitMeasureParameterId?: number;
+    unitId?: number;
+    sortable?: boolean;
+    sortField?: string;
+    filterable?: boolean;
+    filterField?: string;
+    filterType?: FilterType | null;
+    stringFilterType?: StringFilterType;
+    listFilterType?: ListFilterType;
+    strict?: boolean;
+    headCellClass?: string[];
+    cellClass?: string[];
+    data?: any;
+    editable?: boolean | ((coordinates: IColumnRow<any>) => boolean);
+    objectType?: boolean;
+    cellComponent?: Type<CellComponentBase<any>>;
+    headCellComponent?: any;
+    headDropdownConfig?: HeadDropdownTabConfig;
+    filterComponent?: any;
+    columns?: any[];
+    aggregate?: AggregationType;
+    defaultValue?: any;
+    maxValue?: number;
+    minValue?: number;
+    maxLength?: number;
+    required?: boolean;
+    decimalLength?: number;
+    validators?: ValidatorFn[];
+}
+declare class TableColumn extends FilterItem {
+    /**
+     * Ширина
+     */
+    width: number;
+    /**
+     * Коэффициент растяжения ячейки
+     */
+    flex: number;
+    /**
+     * Стобец закреплен
+     */
+    locked: boolean;
+    /**
+     * Название столбца родителя
+     */
+    parentName: string;
+    /**
+     * Единицы измерения
+     */
+    unit: string;
+    unitMeasureParameterId: number;
+    unitId: number;
+    /**
+     * список style классов для шапки таблицы
+     */
+    headCellClass: string[];
+    /**
+     * список style классов для ячейки таблицы
+     */
+    cellClass: string[];
+    /**
+     * Дополнительные данные, свободное описание, доступны внутри компонета ячейки, можно прокинуть callback например
+     */
+    data: any;
+    /**
+     * Колонка доступна для редактирования
+     */
+    editable: boolean | ((coordinates: IColumnRow<any>) => boolean);
+    /**
+     * Компонент для рендера ячейки
+     */
+    cellComponent: any;
+    /**
+     * Компонент для рендера заголовка столбца ячейки
+     */
+    headCellComponent: any;
+    /**
+     * Custom head dropdown for column
+     */
+    headDropdownConfig: HeadDropdownTabConfig;
+    /**
+     * Дочерние колонки
+     */
+    columns: TableColumn[];
+    /**
+     * Aggregate type
+     */
+    aggregate: AggregationType;
+    /**
+     * Значение по умолчанию при создании записи
+     */
+    defaultValue: any;
+    /**
+     * Значение по умолчанию при создании записи
+     */
+    maxValue: number;
+    /**
+     * Значение по умолчанию при создании записи
+     */
+    minValue: number;
+    /**
+     * Максимальная длина
+     */
+    maxLength: number;
+    /**
+     * Поле обязательно для заполнения
+     */
+    required: boolean;
+    /**
+     * Размер дробной части для числовых полей
+     */
+    decimalLength?: number;
+    /**
+     * Функции валидации
+     */
+    validators: ValidatorFn[];
+    /**
+     * Инициализация из анонимного объекта
+     */
+    constructor(options?: ITableColumnOptions);
+}
+
+declare class PropertyGridItemDescriptionDirective {
+    template: TemplateRef<any>;
+    name: string;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyGridItemDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropertyGridItemDescriptionDirective, "[tetaPropertyGridItemDescription]", never, { "name": { "alias": "tetaPropertyGridItemDescription"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PropertyGridComponent<T> {
+    private _formGroup;
+    formClass: boolean;
+    itemTemplates: i0.Signal<readonly PropertyGridItemDescriptionDirective[]>;
+    hideNonEditable: i0.InputSignal<boolean>;
+    columns: i0.InputSignal<TableColumn[]>;
+    dict: i0.InputSignal<IDictionary<IIdName<any>[]>>;
+    item: i0.InputSignal<T>;
+    horizontal: i0.InputSignal<boolean>;
+    decimalPart: i0.InputSignal<number>;
+    controlValueChange: i0.OutputEmitterRef<IIdName<any>>;
+    get formGroup(): FormGroup;
+    constructor(_formGroup: ControlContainer);
+    getEditable(column: TableColumn): boolean;
+    onControlValueChange(event: IIdName<any>): void;
+    private getDictValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyGridComponent<any>, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PropertyGridComponent<any>, "teta-property-grid", never, { "hideNonEditable": { "alias": "hideNonEditable"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "dict": { "alias": "dict"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "decimalPart": { "alias": "decimalPart"; "required": false; "isSignal": true; }; }, { "controlValueChange": "controlValueChange"; }, ["itemTemplates"], never, true, never>;
+}
+
+declare class PropertyGridItemComponent<T> implements OnDestroy, OnChanges {
+    private transloco;
+    private _formGroup;
+    column: i0.InputSignal<TableColumn>;
+    hideNonEditable: i0.InputSignal<boolean>;
+    dict: i0.InputSignal<IDictionary<IIdName<any>[]>>;
+    decimalPart: i0.InputSignal<number>;
+    item: i0.InputSignal<T>;
+    itemTemplates: i0.InputSignal<readonly PropertyGridItemDescriptionDirective[]>;
+    template: i0.Signal<PropertyGridItemDescriptionDirective>;
+    get formGroup(): FormGroup;
+    editable: i0.Signal<boolean>;
+    horizontal: i0.InputSignal<boolean>;
+    controlValueChange: i0.OutputEmitterRef<IIdName<any>>;
+    align: typeof Align;
+    filterTypeEnum: typeof FilterType;
+    private _formSub;
+    caption: i0.Signal<string>;
+    hint: i0.Signal<string>;
+    private _alive;
+    getDict(): IIdName<any>[];
+    controlIsInvalid(controlName: string): boolean;
+    getError(column: TableColumn): string;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyGridItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PropertyGridItemComponent<any>, "teta-property-grid-item", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "hideNonEditable": { "alias": "hideNonEditable"; "required": false; "isSignal": true; }; "dict": { "alias": "dict"; "required": false; "isSignal": true; }; "decimalPart": { "alias": "decimalPart"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": false; "isSignal": true; }; "itemTemplates": { "alias": "itemTemplates"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; }, { "controlValueChange": "controlValueChange"; }, never, never, true, never>;
+}
+
+declare class RadioButtonComponent implements OnInit, OnDestroy {
+    private container;
+    radio: RadioComponent;
+    radioButton: boolean;
+    selected: boolean;
+    checked: boolean;
+    disabled: boolean;
+    set value(val: any);
+    get value(): any;
+    private _value;
+    constructor(container: ViewContainerRef, radio: RadioComponent);
+    hostClick(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, [null, { host: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "teta-radio-button", never, { "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class RadioComponent implements ControlValueAccessor {
+    private _cdr;
+    tabindex: number;
+    radioClass: boolean;
+    /** Менять значение при изменении выбранного */
+    inline: boolean;
+    checkChangeSelected: boolean;
+    set disabled(val: boolean);
+    get disabled(): boolean;
+    get value(): any;
+    set value(val: any);
+    private buttons$;
+    private checkedButton$;
+    private selectedButton$;
+    private disabled$;
+    constructor(_cdr: ChangeDetectorRef);
+    focusHandler(event: FocusEvent): void;
+    focusoutHandler(event: FocusEvent): void;
+    keyEvent(event: KeyboardEvent): boolean;
+    selectFirst(): boolean;
+    _setChecked(btn: RadioButtonComponent): void;
+    _addButton(btn: RadioButtonComponent): number;
+    _removeButton(btn: RadioButtonComponent): void;
+    /** Writes a new value to the element. */
+    writeValue(obj: any): void;
+    /** model callback вызовется когда модель измениться из ui */
+    _onChange: (value: any) => void;
+    /** Registers a callback function that should be called when the control's value changes in the UI */
+    registerOnChange(fn: (value: any) => void): void;
+    _onTouched: () => void;
+    /** Registers a callback function that should be called when the control receives a blur event. */
+    registerOnTouched(fn: () => void): void;
+    /** This function is called by the forms API when the control status changes to or from "DISABLED". */
+    setDisabledState?(isDisabled: boolean): void;
+    private selectBtn;
+    private selectNext;
+    private selectPrevious;
+    private checkSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "teta-radio", never, { "inline": { "alias": "inline"; "required": false; }; "checkChangeSelected": { "alias": "checkChangeSelected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SelectOptionDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOptionDirective, "[tetaSelectOption]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectValueDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectValueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectValueDirective, "[tetaSelectValue]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectComponent implements ControlValueAccessor {
+    private _cdr;
+    private _elementRef;
+    private _config;
+    multiple: boolean;
+    set options(options: any[]);
+    get options(): any[];
+    invalid: boolean;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    autoClose: boolean;
+    autoCloseIgnore: Array<AutoCloseIgnoreCase>;
+    disabled: boolean;
+    itemSize: number;
+    virtual: boolean;
+    icon: string;
+    placeholder: string;
+    appendToBody: boolean;
+    allowNull: boolean;
+    viewType: viewType;
+    notFoundText: string;
+    valueRef: ((item: any) => any) | string;
+    textRef: ((item: any) => string) | string;
+    searchRef: string | ((item: any) => string);
+    optionDirective: SelectOptionDirective;
+    valueDirective: SelectValueDirective;
+    searchInput: ElementRef;
+    set open(value: boolean);
+    get open(): boolean;
+    readonly selectClass = true;
+    private get tabindex();
+    get isDisabled(): boolean;
+    value: any | any[];
+    searchText: string;
+    locale: Observable<TetaLocalisation>;
+    get visibleOptions(): any[];
+    private _options;
+    private _internalValue;
+    private _open;
+    constructor();
+    clear(): void;
+    clickOption(option: any, event: MouseEvent): void;
+    itemSelected(option: any): boolean;
+    removeItemClick(option: any, event: MouseEvent): void;
+    removeItem(option: any): void;
+    search(text: string): void;
+    getText(option: any): string;
+    getValue(option: any): any;
+    getSearchString(option: any): string;
+    focus(): void;
+    writeValue(value: any | any[]): void;
+    onChange: (value: any) => void;
+    registerOnChange(fn: (value: any) => void): void;
+    onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private getSelectedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "teta-select", never, { "multiple": { "alias": "multiple"; "required": false; }; "options": { "alias": "options"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "autoCloseIgnore": { "alias": "autoCloseIgnore"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; "virtual": { "alias": "virtual"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "notFoundText": { "alias": "notFoundText"; "required": false; }; "valueRef": { "alias": "valueRef"; "required": false; }; "textRef": { "alias": "textRef"; "required": false; }; "searchRef": { "alias": "searchRef"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, {}, ["optionDirective", "valueDirective"], never, true, never>;
+}
+
+declare enum SidebarPosition {
+    left = 0,
+    right = 1,
+    bottom = 2,
+    top = 3
+}
+
+declare class SidebarComponent implements OnInit {
+    position: SidebarPosition;
+    backdrop: boolean;
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    className: string | string[];
+    zIndex: number;
+    sidebarPosition: typeof SidebarPosition;
+    constructor();
+    setOpen(value: boolean): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "teta-sidebar", never, { "position": { "alias": "position"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "open": { "alias": "open"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+
+declare class SwitchService {
+    readonly value: Observable<any>;
+    private readonly value$;
+    constructor();
+    setValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchService>;
+}
+
+declare const SWITCH_CONTROL_VALUE_ACCESSOR: any;
+declare class SwitchComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    private svc;
+    private cdr;
+    viewType: viewType;
+    switchClass: boolean;
+    get class(): string;
+    private _alive;
+    private _value;
+    constructor(svc: SwitchService, cdr: ChangeDetectorRef);
+    writeValue(model: any): void;
+    onChange(_: any): void;
+    onTouched(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "teta-switch", never, { "viewType": { "alias": "viewType"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SwitchButtonComponent implements OnInit, OnDestroy {
+    private svc;
+    private cdr;
+    value: any;
+    class: string;
+    private get getClass();
+    private svcValue;
+    private _alive;
+    constructor(svc: SwitchService, cdr: ChangeDetectorRef);
+    click(event: MouseEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchButtonComponent, "teta-switch-button", never, { "value": { "alias": "value"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare abstract class DetailComponentBase<T> {
+    /**
+     * The row details are displayed for
+     */
+    abstract row: T;
+    /**
+     * displayed columns
+     */
+    abstract columns: TableColumn[];
+}
+
+declare class TableComponent<T> implements OnInit, OnDestroy, AfterViewInit, OnChanges {
+    private _svc;
+    private _elementRef;
+    data: T[];
+    columns: TableColumn[];
+    dict: IDictionary<IIdName<any>[]>;
+    filterOptions: IDictionary<IIdName<any>[]>;
+    set state(state: FilterState);
+    cookieName: string;
+    virtual: boolean;
+    detailComponent: Type<DetailComponentBase<T>>;
+    activeRow: T;
+    selectedRows: T[];
+    selectType: SelectType;
+    aggregate: boolean;
+    trackRow: (index: number, row: T) => any;
+    trackColumns: (index: number, column: TableColumn) => any;
+    editType: EditType;
+    editEvent: EditEvent;
+    rowEditable: boolean | ((row: T) => boolean);
+    rowClass: (row: T, index?: number) => string;
+    set scrollToIndex(index: number);
+    showHeadCellMenu: boolean;
+    contextMenu: TemplateRef<any>;
+    contextMenuOpen: boolean;
+    contextMenuOpenChange: EventEmitter<boolean>;
+    stateChange: EventEmitter<FilterState>;
+    bodyLeft: EventEmitter<T>;
+    activeRowChange: EventEmitter<T>;
+    selectedRowsChange: EventEmitter<T[]>;
+    cellClick: EventEmitter<ICellInstanceEvent<T>>;
+    cellDoubleClick: EventEmitter<ICellInstanceEvent<T>>;
+    cellFocus: EventEmitter<ICellInstanceEvent<T>>;
+    cellKeyDown: EventEmitter<ICellInstanceEvent<T>>;
+    rowLeft: EventEmitter<T>;
+    rowEditStart: EventEmitter<ICellInstance<T>>;
+    rowEditEnd: EventEmitter<TableRow<T>>;
+    cellEditStart: EventEmitter<ICellInstance<T>>;
+    cellEditEnd: EventEmitter<ICellInstance<T>>;
+    valueChange: EventEmitter<ICellInstance<T>>;
+    tableService: EventEmitter<TableService<T>>;
+    menu: ElementRef;
+    readonly tableClass = true;
+    rowHeight: i0.InputSignal<number>;
+    selectedRowsList: T[];
+    contextMenuRow: T;
+    verticalAlign: typeof VerticalAlign;
+    align: typeof Align;
+    private _alive;
+    private _headElement;
+    private _state;
+    constructor(_svc: TableService<T>, _elementRef: ElementRef);
+    handleClickOutsideAnyRow(event: MouseEvent): void;
+    focusIn(event: FocusEvent): void;
+    dblclick(event: MouseEvent): void;
+    keydown(event: KeyboardEvent): void;
+    mousedown(event: MouseEvent): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setContextMenuOpen(value: boolean): void;
+    setContextMenuRow(event: MouseEvent): void;
+    private startEditRowOrCell;
+    private getCellElement;
+    private eventIsOnRow;
+    private getCoordinates;
+    private getRow;
+    onScroll: (event: any) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "teta-table", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "dict": { "alias": "dict"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "state": { "alias": "state"; "required": false; }; "cookieName": { "alias": "cookieName"; "required": false; }; "virtual": { "alias": "virtual"; "required": false; }; "detailComponent": { "alias": "detailComponent"; "required": false; }; "activeRow": { "alias": "activeRow"; "required": false; }; "selectedRows": { "alias": "selectedRows"; "required": false; }; "selectType": { "alias": "selectType"; "required": false; }; "aggregate": { "alias": "aggregate"; "required": false; }; "trackRow": { "alias": "trackRow"; "required": false; }; "trackColumns": { "alias": "trackColumns"; "required": false; }; "editType": { "alias": "editType"; "required": false; }; "editEvent": { "alias": "editEvent"; "required": false; }; "rowEditable": { "alias": "rowEditable"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "scrollToIndex": { "alias": "scrollToIndex"; "required": false; }; "showHeadCellMenu": { "alias": "showHeadCellMenu"; "required": false; }; "contextMenu": { "alias": "contextMenu"; "required": false; }; "contextMenuOpen": { "alias": "contextMenuOpen"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; }, { "contextMenuOpenChange": "contextMenuOpenChange"; "stateChange": "stateChange"; "bodyLeft": "bodyLeft"; "activeRowChange": "activeRowChange"; "selectedRowsChange": "selectedRowsChange"; "cellClick": "cellClick"; "cellDoubleClick": "cellDoubleClick"; "cellFocus": "cellFocus"; "cellKeyDown": "cellKeyDown"; "rowLeft": "rowLeft"; "rowEditStart": "rowEditStart"; "rowEditEnd": "rowEditEnd"; "cellEditStart": "cellEditStart"; "cellEditEnd": "cellEditEnd"; "valueChange": "valueChange"; "tableService": "tableService"; }, never, ["*"], true, never>;
+}
+
+declare class TableHeadComponent<T> implements OnInit, OnDestroy {
+    private _svc;
+    private _cdr;
+    selectType: SelectType;
+    showHeadCellMenu: boolean;
+    readonly tableHeadClass = true;
+    state: FilterState;
+    selectTypeEnum: typeof SelectType;
+    lockedFlex: number;
+    lockedWidth: number;
+    private _alive;
+    private _columns;
+    private _hiddenColumns;
+    set columns(columns: TableColumn[]);
+    get columns(): TableColumn[];
+    get locked(): TableColumn[];
+    get unlocked(): TableColumn[];
+    data: T[];
+    constructor(_svc: TableService<T>, _cdr: ChangeDetectorRef);
+    track(index: number, item: TableColumn): any;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeadComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeadComponent<any>, "teta-table-head", never, { "selectType": { "alias": "selectType"; "required": false; }; "showHeadCellMenu": { "alias": "showHeadCellMenu"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableBodyComponent<T> implements OnInit, OnDestroy {
+    private _svc;
+    private _elementRef;
+    private _config;
+    private _cdr;
+    virtual: boolean;
+    activeRow: T;
+    selectedRows: T[];
+    additionalComponent: Type<DetailComponentBase<T>>;
+    aggregate: boolean;
+    selectType: SelectType;
+    rowClass: (row: T, index?: number) => string;
+    trackRow: (index: number, row: T) => any;
+    trackColumns: (index: number, column: TableColumn) => any;
+    viewport: CdkVirtualScrollViewport;
+    rowHeight: i0.InputSignal<number>;
+    readonly tableBodyClass = true;
+    scrollChange: EventEmitter<Event>;
+    set data(data: TableRow<T>[]);
+    get data(): TableRow<T>[];
+    dict: IDictionary<IIdName<any>[]>;
+    locked: TableColumn[];
+    unlocked: TableColumn[];
+    selectTypeEnum: typeof SelectType;
+    aggregationType: typeof AggregationType;
+    lockedFlex: number;
+    lockedWidth: number;
+    totalFlex: number;
+    totalWidth: number;
+    private _columns;
+    private _alive;
+    private _data;
+    private _hiddenColumns;
+    private _obs;
+    set columns(columns: TableColumn[]);
+    get columns(): TableColumn[];
+    locale: Observable<TetaLocalisation>;
+    constructor(_svc: TableService<T>, _elementRef: ElementRef, _config: TetaConfigService, _cdr: ChangeDetectorRef);
+    setActiveRow(row: T, event: MouseEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getAggregateValue(column: TableColumn): number;
+    getAggregateText(column: TableColumn): string;
+    emitScroll(event: any): void;
+    trackTableRow: (index: number, row: TableRow<T>) => any;
+    private addResizeObserver;
+    private removeResizeObserver;
+    private getSum;
+    private getMin;
+    private getMax;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableBodyComponent<any>, "teta-table-body", never, { "virtual": { "alias": "virtual"; "required": false; }; "activeRow": { "alias": "activeRow"; "required": false; }; "selectedRows": { "alias": "selectedRows"; "required": false; }; "additionalComponent": { "alias": "additionalComponent"; "required": false; }; "aggregate": { "alias": "aggregate"; "required": false; }; "selectType": { "alias": "selectType"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "trackRow": { "alias": "trackRow"; "required": false; }; "trackColumns": { "alias": "trackColumns"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; }, { "scrollChange": "scrollChange"; }, never, ["*"], true, never>;
+}
+
+declare class TableRowComponent<T> implements OnChanges {
+    row: TableRow<T>;
+    private _formGroup;
+    get control(): FormControl;
+    get formGroup(): FormGroup;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowComponent<any>, "teta-table-row", never, { "row": { "alias": "row"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HeadCellHostComponent<T> implements OnInit {
+    private viewContainerRef;
+    private _column;
+    private _columns;
+    private _data;
+    private componentRef;
+    private init;
+    set column(column: TableColumn);
+    get column(): TableColumn;
+    set columns(columns: TableColumn[]);
+    get columns(): TableColumn[];
+    set data(data: T[]);
+    get data(): T[];
+    constructor(viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadCellHostComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeadCellHostComponent<any>, "teta-head-cell-host", never, { "column": { "alias": "column"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CellComponent<T> {
+    column: TableColumn;
+    filterOptions: IIdName<any>[];
+    dict: IDictionary<IIdName<any>[]>;
+    row: TableRow<T>;
+    readonly tableCellClass = true;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CellComponent<any>, "teta-cell", never, { "column": { "alias": "column"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "dict": { "alias": "dict"; "required": false; }; "row": { "alias": "row"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CellHostComponent<T> implements OnInit, OnChanges {
+    private viewContainerRef;
+    column: TableColumn;
+    row: TableRow<T>;
+    filterOptions: IIdName<any>[];
+    dict: IDictionary<IIdName<any>[]>;
+    private _init;
+    private _componentRef;
+    constructor(viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellHostComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CellHostComponent<any>, "teta-cell-host", never, { "column": { "alias": "column"; "required": false; }; "row": { "alias": "row"; "required": false; }; "filterOptions": { "alias": "filterOptions"; "required": false; }; "dict": { "alias": "dict"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DateCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    input: DatePickerComponent;
+    open: i0.WritableSignal<boolean>;
+    ngOnInit(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateCellComponent<any>, "teta-date-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class BooleanCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    input: ElementRef;
+    ngOnInit(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BooleanCellComponent<any>, "teta-boolean-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class ColorCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    input: ElementRef;
+    readonly tabindex = 0;
+    focus(event: any): void;
+    setValue(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    getHexColor(color: string): string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorCellComponent<any>, "teta-color-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class DateTimeCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    input: DatePickerComponent;
+    open: i0.WritableSignal<boolean>;
+    ngOnInit(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeCellComponent<any>, "teta-date-time-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    open: i0.WritableSignal<boolean>;
+    get displayFilterOptions(): IIdName<any>[];
+    input: SelectComponent;
+    verticalAlign: typeof VerticalAlign;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    ngOnInit(): void;
+    protected getValue(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListCellComponent<any>, "teta-list-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class NumericCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    input: ElementRef;
+    ngOnInit(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumericCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumericCellComponent<any>, "teta-numeric-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class StringCellComponent<T> extends CellComponentBase<T> implements OnInit {
+    align: typeof Align;
+    input: ElementRef;
+    ngOnInit(): void;
+    startEdit(initiator: ICellCoordinates, type: 'cell' | 'row'): void;
+    stopEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringCellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StringCellComponent<any>, "teta-string-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class HeadCellComponentBase<T> {
+    abstract column: TableColumn;
+    abstract columns: TableColumn[];
+    abstract data: T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadCellComponentBase<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeadCellComponentBase<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare const getCellComponent: (column: TableColumn) => Type<any>;
+
+declare class ColumnReorderEvent {
+    source: TableColumn;
+    target: TableColumn;
+    constructor(source: TableColumn, target: TableColumn);
+}
+
+declare class ColorUtil {
+    static getHexColor(color: string): string;
+}
+
+declare class StateUtil {
+    static hasSortedColumns(state: FilterState): boolean;
+    static hasFilteredColumns(state: FilterState): boolean;
+    static getSortState(state: FilterState, column: TableColumn): SortParam | null;
+    static isColumnFiltered(state: FilterState, column: TableColumn): boolean;
+    static sortColumn(sortEvent: SortEvent, state: FilterState): FilterState;
+    static sortAsc(sortEvent: SortEvent, state: FilterState): FilterState;
+    static sortDesc(sortEvent: SortEvent, state: FilterState): FilterState;
+    static sort(sortEvent: SortEvent, state: FilterState, asc: boolean): FilterState;
+    static clearSortParam(sort: SortParam, sortParams: SortParam[]): SortParam[];
+    static clearSort(column: TableColumn, state: FilterState): FilterState;
+    static clearAllSort(state: FilterState): FilterState;
+}
+
+declare class TableUtil {
+    static getColumnLeaves(column: TableColumn): TableColumn[] | null;
+    static getData<T>(data: T[], state: FilterState): T[];
+    static sortData<T>(data: T[], state: FilterState): T[];
+    static filterData<T>(data: T[], state: FilterState): T[];
+    static filterString<T>(data: T[], filter: StringFilter): T[];
+    static filterDate<T>(data: T[], filter: DateFilter): T[];
+    static filterNumber<T>(data: T[], filter: NumericFilter): T[];
+    static filterList<T>(data: T[], filter: ListFilter): T[];
+    static sort<T>(data: T[], sortParam: SortParam): T[];
+    static desc(field: string): (a: any, b: any) => 1 | -1;
+    static asc(field: string): (a: any, b: any) => 1 | -1;
+}
+
+declare class TabContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabContentDirective, "[tetaTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TabTitleDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabTitleDirective, "[tetaTabTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TabComponent implements AfterContentChecked {
+    /**
+     * Unique tab identifier. Must be unique for the entire document for proper accessibility support.
+     */
+    id: string;
+    /**
+     * Simple (string only) title. Use the "ItskTabTitleDirective" directive for more complex use-cases.
+     */
+    title: string;
+    /**
+     * Allows toggling disabled state of a given state. Disabled tabs can't be selected.
+     */
+    disabled: boolean;
+    titleTpl: TabTitleDirective;
+    contentTpl: TabContentDirective;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "teta-tab", never, { "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["titleTpl", "contentTpl"], never, true, never>;
+}
+
+interface ITabChangeEvent {
+    activeId: string | null;
+    nextId: string;
+    preventDefault: () => void;
+}
+declare class TabsComponent implements AfterContentChecked {
+    classTabs: boolean;
+    get verticalClassTabs(): boolean;
+    /**
+     * An identifier of an initially selected (active) tab. Use the "select" method to switch a tab programmatically.
+     */
+    activeId: string | null;
+    /**
+     * Tabs direction
+     */
+    direction: 'horizontal' | 'vertical';
+    /**
+     * Tabs size
+     */
+    size: 's' | 'm';
+    /**
+     * Whether the closed tabs should be hidden without destroying them
+     */
+    destroyOnHide: boolean;
+    /**
+     * A tab change event fired right before the tab selection happens. See NgbTabChangeEvent for payload details
+     */
+    tabChange: EventEmitter<ITabChangeEvent>;
+    tabs: QueryList<TabComponent>;
+    constructor();
+    /**
+     * Selects the tab with the given id and shows its associated pane.
+     * Any other tab that was previously selected becomes unselected and its associated pane is hidden.
+     */
+    select(tabId: string): void;
+    ngAfterContentChecked(): void;
+    private _getTabById;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "teta-tabs", never, { "activeId": { "alias": "activeId"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "size": { "alias": "size"; "required": false; }; "destroyOnHide": { "alias": "destroyOnHide"; "required": false; }; }, { "tabChange": "tabChange"; }, ["tabs"], ["*"], true, never>;
+}
+
+declare class ThemeSwitchComponent implements OnInit {
+    private _svc;
+    palette: string;
+    view: ButtonViewType;
+    theme: Observable<boolean>;
+    constructor(_svc: ThemeSwitchService);
+    ngOnInit(): void;
+    switchTheme(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThemeSwitchComponent, "teta-theme-switch", never, { "palette": { "alias": "palette"; "required": false; }; "view": { "alias": "view"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const TOGGLE_CONTROL_VALUE_ACCESSOR: any;
+declare class ToggleComponent implements ControlValueAccessor {
+    private cdr;
+    tabindex: number;
+    toggleClass: boolean;
+    get paletteClass(): string;
+    palette: string;
+    noLabel: boolean;
+    /**
+     * компонент неактивен
+     */
+    disabled: boolean;
+    /**
+     * Значение
+     */
+    private model$;
+    get model(): any;
+    set model(v: any);
+    constructor(cdr: ChangeDetectorRef);
+    changeValue(): void;
+    writeValue(model: boolean): void;
+    onChange(_: any): void;
+    onTouched(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "teta-toggle", never, { "palette": { "alias": "palette"; "required": false; }; "noLabel": { "alias": "noLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ToolbarComponent implements OnInit {
+    palette: string;
+    class: any;
+    private get getClass();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "teta-toolbar", never, { "palette": { "alias": "palette"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ITreeData {
+    children?: ITreeData[] | undefined | null;
+    [key: string]: any;
+}
+
+declare class TreeService {
+    openItems: Observable<ITreeData[]>;
+    scrollToIndex: Observable<number>;
+    private _openItems;
+    private _scrollToIndex;
+    constructor();
+    compareItems: (item: ITreeData) => any;
+    openItem(item: ITreeData): void;
+    setOpenItems(items: ITreeData[]): void;
+    scrollTo(index: number): void;
+    private addOrRemove;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeService>;
+}
+
+declare class TetaTemplateDirective {
+    template: TemplateRef<any>;
+    id: string;
+    constructor(template: TemplateRef<any>);
+    getId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TetaTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TetaTemplateDirective, "[tetaTemplate]", never, { "id": { "alias": "tetaTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TreeComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    private treeService;
+    private elementRef;
+    private ngZone;
+    data: i0.InputSignal<ITreeData[]>;
+    padding: i0.InputSignal<number>;
+    childNodeName: i0.InputSignal<string>;
+    virtual: i0.InputSignal<boolean>;
+    height: i0.InputSignal<number>;
+    openItems: i0.ModelSignal<ITreeData[]>;
+    service: EventEmitter<TreeService>;
+    viewport: CdkVirtualScrollViewport;
+    template: TetaTemplateDirective;
+    childPadding: i0.Signal<boolean>;
+    displayData: i0.Signal<ITreeData[]>;
+    private _alive;
+    private _obs;
+    constructor();
+    set compareItems(func: (item: ITreeData) => any);
+    get compareItems(): (item: ITreeData) => any;
+    readonly treeClass = true;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    trackRow: (index: number, item: ITreeData) => any;
+    private getDisplayData;
+    private addResizeObserver;
+    private removeResizeObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "teta-tree", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "childNodeName": { "alias": "childNodeName"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "openItems": { "alias": "openItems"; "required": false; "isSignal": true; }; "compareItems": { "alias": "compareItems"; "required": false; }; }, { "openItems": "openItemsChange"; "service": "service"; }, ["template"], never, true, never>;
+}
+
+declare class TreeItemToggleComponent {
+    treeService: TreeService;
+    item: i0.InputSignal<ITreeData>;
+    open: Signal<boolean>;
+    openItems: Signal<ITreeData[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeItemToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeItemToggleComponent, "teta-tree-item-toggle", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StepperComponent {
+    steps: i0.InputSignal<IIdName<number>[]>;
+    currentStepId: i0.InputSignal<number>;
+    currentIndex: Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "app-stepper", never, { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "currentStepId": { "alias": "currentStepId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DividerComponent implements OnInit {
+    label: any;
+    template: TemplateRef<any>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DividerComponent, "teta-divider", never, { "label": { "alias": "label"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ResizePanelComponent implements OnInit, OnDestroy {
+    private _elementRef;
+    private _renderer;
+    private _document;
+    size: number;
+    set direction(val: 'vertical' | 'horizontal');
+    get direction(): "vertical" | "horizontal";
+    get icon(): "moreHorizontal" | "moreVertical";
+    set grabPosition(val: 'top' | 'left' | 'bottom' | 'right');
+    get grabPosition(): "top" | "left" | "bottom" | "right";
+    name: string;
+    minSize: number;
+    maxSize: number;
+    readonly resizePanelClass = true;
+    private _direction;
+    private _grabPosition;
+    private _startSize;
+    private _startPosition;
+    private _positionMap;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _document: any);
+    resizeStart(event: MouseEvent): void;
+    resizeProcess(event: MouseEvent): void;
+    resizeEnd(event: MouseEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getClassName(): string;
+    private setStartPosition;
+    private manageHorizontal;
+    private manageVertical;
+    private restore;
+    private restorePosition;
+    private save;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizePanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizePanelComponent, "teta-resize-panel", never, { "size": { "alias": "size"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "grabPosition": { "alias": "grabPosition"; "required": false; }; "name": { "alias": "name"; "required": false; }; "minSize": { "alias": "minSize"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AutoPositionDirective implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _zone;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    fixed: string;
+    private _alive;
+    constructor(_elementRef: ElementRef, _zone: NgZone);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoPositionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoPositionDirective, "[tetaAutoPosition]", never, { "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ClickOutsideDirective implements OnDestroy {
+    private _elementRef;
+    private _ngZone;
+    clickOutside: EventEmitter<MouseEvent>;
+    rightClick: boolean;
+    private _handleEvents;
+    set tetaClickOutside(val: boolean);
+    get tetaClickOutside(): boolean;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone);
+    ngOnDestroy(): void;
+    private addListener;
+    private removeListener;
+    private listener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[tetaClickOutside]", never, { "rightClick": { "alias": "rightClick"; "required": false; }; "tetaClickOutside": { "alias": "tetaClickOutside"; "required": false; }; }, { "clickOutside": "clickOutside"; }, never, never, true, never>;
+}
+
+declare abstract class DynamicContentBaseDirective implements OnDestroy {
+    protected _document: Document;
+    protected _elementRef: ElementRef<any>;
+    protected _service: DynamicComponentService;
+    protected _injector: Injector;
+    protected _zone: NgZone;
+    protected _cdr: ChangeDetectorRef;
+    data: any;
+    className?: string | string[];
+    align: Align;
+    verticalAlign: VerticalAlign;
+    appendToBody: boolean;
+    set open(open: boolean);
+    openChange: EventEmitter<boolean>;
+    protected _alive: boolean;
+    protected _componentRef?: ComponentRef<any> | null;
+    protected _content?: TetaContentRef;
+    protected _open: boolean;
+    protected abstract get _dynamicContent(): string | TemplateRef<any> | Type<any> | null | undefined;
+    protected constructor();
+    ngOnDestroy(): void;
+    protected createContentRef<T>(className?: string | string[]): ComponentRef<T>;
+    protected destroyContentRef(): void;
+    protected abstract setPosition(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicContentBaseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicContentBaseDirective, never, never, { "data": { "alias": "data"; "required": false; }; "className": { "alias": "className"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, never, true, never>;
+}
+
+declare class ContextMenuDirective extends DynamicContentBaseDirective implements OnDestroy {
+    private _click;
+    /**
+     * Строка, шаблон или компонент для создания контекстного меню
+     */
+    tetaContextMenu: string | TemplateRef<any> | Type<any>;
+    autoCloseIgnore: AutoCloseIgnoreCase[];
+    get _dynamicContent(): string | Type<any> | TemplateRef<any>;
+    private _eventPoint;
+    constructor();
+    showContent(event: MouseEvent): void;
+    click(event: MouseEvent): void;
+    documentClick(event: MouseEvent): void;
+    protected addScrollListener(): void;
+    protected removeScrollListener(): void;
+    private scrollListener;
+    ngOnDestroy(): void;
+    protected setPosition(): void;
+    private createMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuDirective, "[tetaContextMenu]", never, { "tetaContextMenu": { "alias": "tetaContextMenu"; "required": false; }; "autoCloseIgnore": { "alias": "autoCloseIgnore"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DisableControlDirective implements OnInit {
+    private ngControl;
+    private disabled;
+    set tetaDisableControl(val: boolean);
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    private toggleControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisableControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DisableControlDirective, "[tetaDisableControl]", never, { "tetaDisableControl": { "alias": "tetaDisableControl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DragContainerInstance<T> {
+    data: T[];
+    previewTemplate: TemplateRef<any>;
+    viewContainer: ViewContainerRef;
+    constructor(options: {
+        data: T[];
+        previewTemplate: TemplateRef<any>;
+        viewContainer: ViewContainerRef;
+    });
+}
+
+declare class DragInstance<T> {
+    container: DragContainerInstance<T>;
+    data: T;
+    constructor(options?: {
+        container: DragContainerInstance<T>;
+        data: T;
+    });
+}
+
+interface DragSelection<T> {
+    container: DragContainerInstance<T>;
+    items: DragInstance<T>[];
+}
+
+type DropTarget<T> = DragInstance<T> | DragContainerInstance<T>;
+
+interface DropEvent<T> {
+    container: DragContainerInstance<T>;
+    target: DropTarget<T>;
+    data: DragInstance<T>[];
+}
+
+declare class DragDirective<T> implements OnInit, OnDestroy {
+    private readonly _container;
+    private readonly _dragService;
+    private readonly _zone;
+    private readonly _cdr;
+    data: T;
+    allowDrag: boolean;
+    allowDrop: boolean;
+    allowDropPredicate: (data: DragSelection<T>, target: T) => boolean;
+    tetaDragEnter: EventEmitter<DragInstance<T>>;
+    tetaDrop: EventEmitter<DropEvent<T>>;
+    dropTarget: DropTarget<T>;
+    instance: DragInstance<T>;
+    get selection(): boolean;
+    get isDropTarget(): boolean;
+    private _alive;
+    mousedown(event: MouseEvent | TouchEvent): void;
+    mouseenter(event: MouseEvent): void;
+    mouseleave(event: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragDirective<any>, "[tetaDrag]", ["drag"], { "data": { "alias": "tetaDrag"; "required": false; }; "allowDrag": { "alias": "allowDrag"; "required": false; }; "allowDrop": { "alias": "allowDrop"; "required": false; }; "allowDropPredicate": { "alias": "allowDropPredicate"; "required": false; }; }, { "tetaDragEnter": "tetaDragEnter"; "tetaDrop": "tetaDrop"; }, never, never, true, never>;
+}
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface DragProcess<T> {
+    selection: DragSelection<T>;
+}
+
+declare class DragDropService<T> {
+    private _document;
+    private _rendererFactory;
+    selection: DragSelection<T>;
+    startPosition: Point;
+    dragProcess: DragProcess<T>;
+    dropTarget: Observable<DropTarget<T>>;
+    dropped: Observable<DropEvent<T>>;
+    private dropTarget$;
+    private _delta;
+    private _renderer;
+    private _preview;
+    private _previewRef;
+    private dropped$;
+    constructor(_document: Document, _rendererFactory: RendererFactory2);
+    setDropTarget(target: DropTarget<T>): void;
+    setStartPosition(point: Point): void;
+    setSelection(instance: DragInstance<T>, container: DragContainerInstance<T>): void;
+    addSelection(instance: DragInstance<T>, container: DragContainerInstance<T>): void;
+    clearSelection(): void;
+    cancelDrag(): void;
+    startProcess(): void;
+    stopProcess(): void;
+    private getDelta;
+    private createPreview;
+    private movePreview;
+    private destroyPreview;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropService<any>>;
+}
+
+declare class DragContainerDirective<T> implements OnInit, OnDestroy {
+    private _dragService;
+    private _elementRef;
+    private _viewContainerRef;
+    private _zone;
+    private _cdr;
+    data: T[];
+    multiple: boolean;
+    allowDrop: boolean;
+    tetaDrop: EventEmitter<DropEvent<T>>;
+    tetaDragEnter: EventEmitter<DragInstance<T>>;
+    private _previewTemplate;
+    instance: DragContainerInstance<T>;
+    dropTarget: DropTarget<T>;
+    private _alive;
+    get isDropTarget(): boolean;
+    mouseleave(event: any): void;
+    mouseover(event: any): void;
+    escape(event: any): void;
+    constructor(_dragService: DragDropService<T>, _elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _zone: NgZone, _cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragContainerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragContainerDirective<any>, "[tetaDragContainer]", ["dragContainer"], { "data": { "alias": "tetaDragContainer"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "allowDrop": { "alias": "allowDrop"; "required": false; }; }, { "tetaDrop": "tetaDrop"; "tetaDragEnter": "tetaDragEnter"; }, ["_previewTemplate"], never, true, never>;
+}
+
+declare class DragPlaceholderDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragPlaceholderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragPlaceholderDirective, "[tetaDragPlaceholder]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DragPreviewDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragPreviewDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragPreviewDirective, "[tetaDragPreview]", never, {}, {}, never, never, true, never>;
+}
+
+interface DragSortEvent<T> {
+    previousIndex: number;
+    newIndex: number;
+    source: T;
+    target: T;
+    list: T[];
+}
+
+declare class DragSortContainerDirective<T> {
+    dragSortList: T[];
+    dragSorted: EventEmitter<DragSortEvent<T>>;
+    private _dragItem;
+    drop(event: DragEvent): void;
+    setDragItem(item: T | null): void;
+    getDragItem(): T | null;
+    getList(): T[];
+    setList(list: T[]): void;
+    updateSortOrder(source: T, target: T, insertBefore: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragSortContainerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragSortContainerDirective<any>, "[tetaDragSortContainer]", never, { "dragSortList": { "alias": "dragSortList"; "required": false; }; }, { "dragSorted": "dragSorted"; }, never, never, true, never>;
+}
+
+declare class DragSortItemDirective<T> implements OnInit, OnDestroy {
+    private readonly _container;
+    private readonly _elementRef;
+    private readonly _renderer;
+    tetaDragSortItem: T;
+    dragSortDirection: 'horizontal' | 'vertical';
+    readonly draggable = true;
+    readonly relative = true;
+    private _dragElement;
+    private rect;
+    dragstart(event: DragEvent): void;
+    dragenter(event: DragEvent): void;
+    dragover(event: DragEvent): void;
+    dragleave(event: DragEvent): void;
+    dragend(event: DragEvent): void;
+    drop(event: DragEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private showDrag;
+    private hideDrag;
+    private createDrag;
+    private destroyDrag;
+    private getDropPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragSortItemDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragSortItemDirective<any>, "[tetaDragSortItem]", never, { "tetaDragSortItem": { "alias": "tetaDragSortItem"; "required": false; }; "dragSortDirection": { "alias": "dragSortDirection"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FullScreenDirective {
+    private service;
+    elementRef: ElementRef<any>;
+    enter(): Promise<void>;
+    exit(): Promise<void>;
+    toggle(): Promise<void>;
+    onEsc(ev: Event): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FullScreenDirective, "[tetaFullScreen]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FullScreenService {
+    private active?;
+    enter(el: Element): Promise<void>;
+    exit(): Promise<void>;
+    toggle(el: Element): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullScreenService>;
+}
+
+declare class FullScreenToggleDirective {
+    private fullScreen;
+    onClick(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FullScreenToggleDirective, "[tetaFullScreenToggle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HighlightDirective {
+    private elementRef;
+    set tetaHighlight(text: string);
+    private _initialElement;
+    constructor(elementRef: ElementRef);
+    private recursiveReplaceNode;
+    private wrapNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightDirective, "[tetaHighlight]", never, { "tetaHighlight": { "alias": "tetaHighlight"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HintDirective extends DynamicContentBaseDirective implements OnDestroy {
+    /**
+     * Строка, шаблон или компонент для создания контекстного меню
+     */
+    tetaHint?: string | TemplateRef<any> | Type<any>;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    delay: number;
+    viewType: viewType;
+    overflownOnly: boolean;
+    get _dynamicContent(): string | Type<any> | TemplateRef<any>;
+    private _timeout?;
+    private _componentRect;
+    constructor();
+    mouseenter(): void;
+    mouseleave(): void;
+    click(event: MouseEvent): void;
+    protected setPosition(): void;
+    private createHint;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HintDirective, "[tetaHint]", never, { "tetaHint": { "alias": "tetaHint"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "overflownOnly": { "alias": "overflownOnly"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LoaderDirective implements OnDestroy {
+    private _elementRef;
+    private _renderer;
+    private _document;
+    protected _zone: NgZone;
+    appendToBody: boolean;
+    mask: boolean;
+    set tetaLoader(value: boolean);
+    get tetaLoader(): boolean;
+    private _element;
+    private _loader;
+    private _mask;
+    private _alive;
+    private _loading;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _document: any, _zone: NgZone);
+    ngOnDestroy(): void;
+    private show;
+    private hide;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LoaderDirective, "[tetaLoader]", never, { "appendToBody": { "alias": "appendToBody"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "tetaLoader": { "alias": "tetaLoader"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class OnlyNumberDirective {
+    private _elementRef;
+    private _control;
+    tetaOnlyNumber: boolean;
+    allowDecimals: boolean;
+    allowSign: boolean;
+    decimalSeparator: string;
+    commaSeparator: string;
+    onlyPositive: boolean;
+    private _previousValue;
+    private _integerUnsigned;
+    private _integerSigned;
+    private _decimalUnsigned;
+    private _decimalSigned;
+    private readonly _minusSign;
+    constructor(_elementRef: ElementRef<HTMLInputElement>, _control: NgControl);
+    onChange(e: any): void;
+    onBlur(e: any): void;
+    dblclick(e: any): void;
+    onPaste(e: any): void;
+    onKeyDown(e: KeyboardEvent): void;
+    validateValue(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OnlyNumberDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OnlyNumberDirective, "[tetaOnlyNumber]", never, { "tetaOnlyNumber": { "alias": "tetaOnlyNumber"; "required": false; }; "allowDecimals": { "alias": "allowDecimals"; "required": false; }; "allowSign": { "alias": "allowSign"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "commaSeparator": { "alias": "commaSeparator"; "required": false; }; "onlyPositive": { "alias": "onlyPositive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TooltipDirective extends DynamicContentBaseDirective implements OnDestroy, OnInit {
+    private _click;
+    /**
+     * Строка, шаблон или компонент для создания контекстного меню
+     */
+    tetaTooltip?: string | TemplateRef<any> | Type<any> | null | undefined;
+    align: Align;
+    verticalAlign: VerticalAlign;
+    private _componentRect;
+    get _dynamicContent(): string | Type<any> | TemplateRef<any>;
+    showContent(event: MouseEvent): void;
+    ngOnInit(): void;
+    protected setPosition(): void;
+    private createTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[tetaTooltip]", never, { "tetaTooltip": { "alias": "tetaTooltip"; "required": false; }; "align": { "alias": "align"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NoAutofillDirective implements OnInit {
+    private _renderer;
+    private _elementRef;
+    constructor(_renderer: Renderer2, _elementRef: ElementRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoAutofillDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NoAutofillDirective, "[tetaNoAutofill]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ResizeDragDirective {
+    private _document;
+    tetaResizeDrag: 'horizontal' | 'vertical';
+    resizeStart: EventEmitter<MouseEvent>;
+    resizeProcess: EventEmitter<MouseEvent>;
+    resizeEnd: EventEmitter<MouseEvent>;
+    _active: boolean;
+    get horizontal(): boolean;
+    get vertical(): boolean;
+    mouseDown(event: MouseEvent): void;
+    private addListeners;
+    private removeListeners;
+    private handleMouseUp;
+    private handleMouseMove;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDragDirective, "[tetaResizeDrag]", never, { "tetaResizeDrag": { "alias": "tetaResizeDrag"; "required": false; }; }, { "resizeStart": "resizeStart"; "resizeProcess": "resizeProcess"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+}
+
+declare class LetDirective<T> {
+    tetaLet: T;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<LetContext<T>>);
+    static ngTemplateContextGuard<T>(_dir: LetDirective<T>, _ctx: any): _ctx is LetDirective<Exclude<T, null | undefined>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LetDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LetDirective<any>, "[tetaLet]", never, { "tetaLet": { "alias": "tetaLet"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class LetContext<T> implements ContextWithImplicit<T> {
+    private readonly internalDirectiveInstance;
+    constructor(internalDirectiveInstance: LetDirective<T>);
+    get $implicit(): T;
+    get tetaLet(): T;
+}
+interface ContextWithImplicit<T> {
+    $implicit: T;
+}
+
+declare class ScrollableDirective {
+    readonly hideScrollClass = true;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollableDirective, "[tetaScrollable]", never, {}, {}, never, never, true, never>;
+}
+
+type ScrollDimensions = {
+    clientHeight: number;
+    clientWidth: number;
+    scrollHeight: number;
+    scrollWidth: number;
+};
+declare class ScrollableComponent implements OnInit, OnDestroy {
+    private _scrollDirective;
+    private _scrollableWrapper;
+    private _scrollbarVertical;
+    private _scrollbarHorizontal;
+    direction: 'row' | 'column';
+    showScrollbars: boolean;
+    contentClass: string | string[];
+    scroll: EventEmitter<Event>;
+    private _scrollSize;
+    scrollSize: Observable<ScrollDimensions>;
+    private _container;
+    private _alive;
+    private resizeObserver;
+    private mutationObserver;
+    constructor();
+    private _observe;
+    scrollVertical(event: any): void;
+    scrollHorizontal(event: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollableComponent, "teta-scrollable", never, { "direction": { "alias": "direction"; "required": false; }; "showScrollbars": { "alias": "showScrollbars"; "required": false; }; "contentClass": { "alias": "contentClass"; "required": false; }; }, { "scroll": "scroll"; }, ["_scrollDirective"], ["*"], true, never>;
+}
+
+declare class ScrollIntoViewDirective implements OnChanges {
+    private platformId;
+    private elementRef;
+    tetaScrollIntoView: boolean | undefined;
+    behavior: ScrollBehavior;
+    block: ScrollLogicalPosition;
+    constructor(platformId: any, elementRef: ElementRef);
+    ngOnChanges(simpleChange: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollIntoViewDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollIntoViewDirective, "[tetaScrollIntoView]", never, { "tetaScrollIntoView": { "alias": "tetaScrollIntoView"; "required": false; }; "behavior": { "alias": "behavior"; "required": false; }; "block": { "alias": "block"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberPipe implements PipeTransform {
+    transform(value: number | string | null | undefined, decimalLength?: number, chunkDelimiter?: string, decimalDelimiter?: string, chunkLength?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberPipe, "tetaNumber", true>;
+}
+
+declare class PrependZeroPipe implements PipeTransform {
+    transform(value: number, length: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrependZeroPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrependZeroPipe, "tetaPrependZero", true>;
+}
+
+declare class TetaDatePipe implements PipeTransform {
+    private _transloco;
+    dateFormatMap: Map<string, string>;
+    constructor(_transloco: TranslocoService);
+    transform(value: Date, format?: string, timez?: string, locale?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TetaDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TetaDatePipe, "tetaDate", true>;
+}
+
+declare const getPrecision: (a: number) => number;
+declare const formatNumber: (value: any, decimalLength: number, chunkDelimiter: string, decimalDelimiter: string, chunkLength: number) => string;
+declare const prependZero: (input: number, length: number) => string;
+
+type Ctor<T> = new (...params: any[]) => T;
+
+interface IId {
+    id: any;
+}
+
+interface IRect {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+    maxHeight?: number;
+    minWidth?: number;
+}
+
+declare class ClickService {
+    protected _document: any;
+    click: Observable<MouseEvent>;
+    contextMenu: Observable<MouseEvent>;
+    constructor(_document: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickService>;
+}
+
+declare class OverlayContainerService implements OnDestroy {
+    private document$;
+    private _containerClass;
+    private _container?;
+    constructor(document$: any);
+    getContainer(): HTMLElement | undefined;
+    private createContainer;
+    private removeContainer;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayContainerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayContainerService>;
+}
+
+declare class ArrayUtil {
+    static asArray<T>(value: T | T[]): T[];
+    static flatten(data: any[], children?: string | ((item: any) => any[]), onlyLeafs?: boolean): any[];
+    static findRecursive(tree: any[], comparer: (iterableNode: any) => boolean, children?: string): any;
+    static filterRecursive(array: any[], filter: (item: any) => boolean, children?: string, keepChildren?: boolean, fullscanChildren?: boolean): any;
+    static distinct<T>(array: T[], comparator: (item: T) => any): T[];
+    static findParents(tree: any[], item: any): any[] | null;
+    static moveItem(list: any[], sourceIndex: number, targetIndex: number): any[];
+}
+
+declare class DomUtil {
+    static clickedInside(target: HTMLElement | undefined | null, event: MouseEvent): boolean;
+    static findTransformedParent(node: HTMLElement): HTMLElement;
+    static isOverflown(element: HTMLElement): boolean;
+}
+
+declare class PositionUtil {
+    static getPosition(containerPosition: IRect, elementPosition: IRect, align: Align, verticalAlign: VerticalAlign, margin?: number, verticalMargin?: number, transformedParentRect?: IRect): IRect;
+    static setElementPosition(element: HTMLElement, rect: IRect): void;
+    static getMaxHeight(position: IRect): number | null;
+    static getMaxWidth(position: IRect): number | null;
+}
+
+declare function boolOrFuncCallback<M>(variable: boolean | ((row: M | undefined) => boolean)): (args: M) => boolean;
+
+declare class DateUtil {
+    /**
+     * Вычесть n-дней
+     */
+    static subtractDays(date: Date, days?: number): Date | null;
+    /**
+     * Добавить n-дней
+     */
+    static addDays(date: Date, days?: number): Date | null;
+    /**
+     * Получить дату из строки
+     */
+    static parseString(dat: string): Date | null;
+    /**
+     * Привести дату к строке
+     */
+    static toString(dat: Date): string;
+    /**
+     * Привести дату к строке без часов и минут
+     */
+    static toShortString(dat: Date): string;
+    /**
+     * Подготовка даты к отправке на сервер, чтобы небыло смещения часов
+     */
+    static convertUTC2DateLocal(date?: Date): Date | null;
+    /**
+     * Подготовка даты к отправке на сервер, чтобы небыло смещения часов
+     */
+    static convertDateLocal2UTC(date?: Date): Date | null;
+    static convertDateStringsToDates(input: any): any;
+    static convertDates(input: any | any[]): any | any[];
+    static getMonthDaysCount(date: Date): number;
+    static getRangeOfMonths(start: Date, end: Date): Date[];
+    static truncateToMonth(date: Date): Date;
+    static truncateToDay(date: Date): Date;
+    static truncateToHour(date: Date): Date;
+    static toISOString(date: number): string;
+    static isValidDate(date: any): boolean;
+    static millisecondToHumanFormat(milliSeconds: number, maxValue?: number, showDays?: boolean): string;
+    private static fillConvertDates;
+    private static fillConvertDateStringsToDates;
+    private static convertStringToLocalDate;
+}
+
+declare enum ExportType {
+    png = 0,
+    svg = 1,
+    jpeg = 2,
+    blob = 3,
+    canvas = 4,
+    pixelData = 5
+}
+type ExportOptions = {
+    filter: (node: HTMLElement) => boolean;
+};
+declare const exportDomToImage: (node: HTMLElement, type?: ExportType, options?: ExportOptions) => any;
+
+declare class FormsUtil {
+    static validateAllFormFields(formGroup: UntypedFormGroup): void;
+    static controlIsInvalid(formGroup: UntypedFormGroup, controlName: string): boolean;
+    static getControlErrors(formGroup: UntypedFormGroup, controlName: string): string[];
+    static matchValuesValidator(matchTo: string): (control: AbstractControl) => ValidationErrors | null;
+    static requiredIf(value: boolean): (control: AbstractControl) => ValidationErrors | null;
+    static initFormFromColumns(columns: TableColumn[], dataItem: any): UntypedFormGroup;
+    static initControlFromColumn(column: TableColumn, dataItem: any): UntypedFormControl;
+    static getValidators(column: TableColumn): any[];
+    static validatorNotEmpty(control: AbstractControl): ValidationErrors | null;
+    static formProvider: Provider;
+}
+
+declare function isFunction(obj: any): boolean;
+
+declare class StringUtil {
+    static firstLetterToLower(input: string): string;
+    static firstLetterToUpper(input: string): string;
+}
+
+declare const ruLocale: TetaLocalisation;
+
+declare const enLocale: TetaLocalisation;
+
+declare const ANIMATION_FRAME: InjectionToken<Observable<number>>;
+declare const WINDOW: InjectionToken<Window>;
+
+declare function tetaZoneFull<T>(ngZone: NgZone): MonoTypeOperatorFunction<T>;
+declare function tetaZoneFree<T>(ngZone: NgZone): MonoTypeOperatorFunction<T>;
+declare function tetaZoneOptimized<T>(ngZone: NgZone): MonoTypeOperatorFunction<T>;
+
+export { ANIMATION_FRAME, AccordionComponent, AccordionContentDirective, AccordionHeadComponent, AccordionItemComponent, AggregationType, Align, ArrayUtil, AutoPositionDirective, AutocompleteComponent, AvatarComponent, BooleanCellComponent, BooleanFilter, BooleanFilterComponent, ButtonComponent, CHECKBOX_CONTROL_VALUE_ACCESSOR, CellComponent, CellComponentBase, CellHostComponent, Chart3dComponent, Chart3dOptions, CheckboxComponent, ClickOutsideDirective, ClickService, ColorCellComponent, ColorInputComponent, ColorUtil, ColumnReorderEvent, ColumnResizeEvent, ContextMenuDirective, CurrentModal, DATE_PICKER_CONTROL_VALUE_ACCESSOR, DATE_Range_CONTROL_VALUE_ACCESSOR, DateCalendarComponent, DateCellComponent, DateFilter, DateFilterComponent, DateFilterValue, DatePeriod, DatePickerComponent, DatePickerMode, DateRangeComponent, DateTimeCellComponent, DateUtil, DayModel, DelimiterComponent, DetailComponentBase, DialogComponent, DialogService, DisableControlDirective, DividerComponent, DomUtil, DragContainerDirective, DragContainerInstance, DragDirective, DragDropService, DragInstance, DragPlaceholderDirective, DragPreviewDirective, DragSortContainerDirective, DragSortItemDirective, DropdownComponent, DropdownContentDirective, DropdownDirective, DropdownHeadDirective, DynamicComponentService, DynamicContentBaseDirective, DynamicData, EditEvent, EditType, ExpandCardComponent, ExpandItemComponent, ExpandPanelComponent, ExpandPanelContentDirective, ExpandPanelHeadDirective, ExportType, FileItemComponent, FileUploadAreaComponent, FilterBase, FilterComponentBase, FilterHostComponent, FilterItem, FilterState, FilterType, FormGroupTitleComponent, FormsUtil, FullScreenDirective, FullScreenService, FullScreenToggleDirective, HeadCellComponentBase, HeadCellHostComponent, HighlightDirective, HintDirective, IconComponent, IconFileComponent, IconService, IconSpriteDirective, InputComponent, LetContext, LetDirective, ListCellComponent, ListFilter, ListFilterComponent, ListFilterType, LoaderDirective, Message, MessageComponent, MessageHostComponent, MessageService, ModalCloseReason, ModalContainerComponent, ModalInstance, ModalModule, ModalService, NoAutofillDirective, NumberPipe, NumericCellComponent, NumericFilter, NumericFilterComponent, NumericFilterValue, OnlyNumberDirective, OverlayContainerService, PagerComponent, PagerState, PagerUtil, PanelComponent, PopupContentComponent, PositionUtil, PrependZeroPipe, ProgressBarComponent, PropertyGridComponent, PropertyGridItemComponent, PropertyGridItemDescriptionDirective, RadioButtonComponent, RadioComponent, RangeCalendarComponent, ResizeDragDirective, ResizePanelComponent, SLIDER_CONTROL_VALUE_ACCESSOR, SWITCH_CONTROL_VALUE_ACCESSOR, ScrollIntoViewDirective, ScrollableComponent, ScrollableDirective, SelectComponent, SelectOptionDirective, SelectType, SelectValueDirective, Series3d, SidebarComponent, SidebarPosition, SortEvent, SortParam, StateUtil, StepperComponent, StringCellComponent, StringFilter, StringFilterComponent, StringFilterType, StringUtil, SwitchButtonComponent, SwitchComponent, TOGGLE_CONTROL_VALUE_ACCESSOR, TabComponent, TabContentDirective, TabTitleDirective, TableBodyComponent, TableColumn, TableColumnStore, TableComponent, TableHeadComponent, TableRow, TableRowComponent, TableService, TableUtil, TabsComponent, TetaConfigService, TetaContentRef, TetaDatePipe, TetaSize, TetaTemplateDirective, TextFieldComponent, ThemeSwitchComponent, ThemeSwitchService, ToggleComponent, ToolbarComponent, TooltipDirective, TreeComponent, TreeItemToggleComponent, TreeService, VerticalAlign, WINDOW, boolOrFuncCallback, enLocale, exportDomToImage, formatNumber, getCellComponent, getPrecision, isFunction, prependZero, ruLocale, tetaZoneFree, tetaZoneFull, tetaZoneOptimized };
+export type { AutoCloseIgnoreCase, Base3dPoint, ButtonViewType, ContextWithImplicit, Ctor, DateFromToModel, DragProcess, DragSelection, DragSortEvent, DropEvent, DropTarget, ExportOptions, HeadDropdownTab, HeadDropdownTabConfig, ICellCoordinates, ICellEvent, ICellInstance, ICellInstanceEvent, ICellInstanceValue, ICellValue, IColumnRow, IDictionary, IFilter, IFilterItemOptions, IId, IIdName, IModalConfig, IModalResult, IRect, ITabChangeEvent, ITableColumnOptions, ITreeData, IntersectionResult, MinMaxDateModel, Point, TetaLocalisation, WellMeshData, viewType };