import * as i0 from '@angular/core';
import { SimpleChanges, ElementRef, OnChanges, OnInit, EventEmitter, ChangeDetectorRef, NgZone, InjectionToken, Provider, OnDestroy, AfterContentInit, AfterViewChecked, AfterViewInit, ViewContainerRef, TemplateRef, QueryList, AfterContentChecked, Injector, ApplicationRef, ModuleWithProviders, PipeTransform, Type, Renderer2, DoCheck, ComponentRef } from '@angular/core';
import * as _angular_platform_browser from '@angular/platform-browser';
import { SafeUrl, SafeStyle, DomSanitizer, HammerLoader, Title } from '@angular/platform-browser';
import * as i3 from '@angular/forms';
import { NgForm, ControlValueAccessor, Validator, ValidatorFn, AbstractControl, ValidationErrors, UntypedFormControl } from '@angular/forms';
import * as i2 from '@angular/common';
import * as i4 from '@angular/router';
import { ActivatedRoute, Router, ActivatedRouteSnapshot, RouterStateSnapshot, UrlSerializer, UrlTree } from '@angular/router';
import * as i5 from 'ngx-scrollbar';
import { NgScrollbar } from 'ngx-scrollbar';
import * as i6 from '@angular/cdk/table';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i18 from '@angular/material/core';
import { ThemePalette, MatOption, NativeDateAdapter } from '@angular/material/core';
import * as i19 from '@angular/cdk/overlay';
import { Overlay, ScrollStrategy, OverlayRef, OverlayConfig, NoopScrollStrategy } from '@angular/cdk/overlay';
import * as i20 from '@angular/cdk/portal';
import { TemplatePortal, ComponentPortal, ComponentType } from '@angular/cdk/portal';
import * as rxjs from 'rxjs';
import { Observable, Subject, ReplaySubject, MonoTypeOperatorFunction, Subscription } from 'rxjs';
import * as i14 from '@angular/material/form-field';
import { MatFormField } from '@angular/material/form-field';
import * as i4$1 from '@angular/material/button';
import * as i15 from '@angular/material/input';
import * as i14$1 from '@angular/material/icon';
import * as i11 from '@angular/material/divider';
import * as i21 from '@angular/cdk/a11y';
import * as i22 from '@angular/cdk/scrolling';
import * as i1 from '@angular/cdk/platform';
import * as i1$1 from '@angular/material/autocomplete';
import * as i2$1 from '@angular/material/badge';
import * as i3$1 from '@angular/material/bottom-sheet';
import * as i5$1 from '@angular/material/button-toggle';
import * as i6$1 from '@angular/material/card';
import * as i7 from '@angular/material/checkbox';
import * as i8 from '@angular/material/chips';
import * as i9 from '@angular/material/datepicker';
import * as i10 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import * as i12 from '@angular/material/expansion';
import { MatAccordion } from '@angular/material/expansion';
import * as i13 from '@angular/material/grid-list';
import * as i16 from '@angular/material/list';
import * as i17 from '@angular/material/menu';
import { MatMenuTrigger, MatMenuPanel } from '@angular/material/menu';
import * as i19$1 from '@angular/material/paginator';
import { MatPaginator } from '@angular/material/paginator';
import * as i20$1 from '@angular/material/progress-bar';
import * as i21$1 from '@angular/material/progress-spinner';
import * as i22$1 from '@angular/material/radio';
import * as i23 from '@angular/material/select';
import { MatSelect } from '@angular/material/select';
import * as i24 from '@angular/material/sidenav';
import * as i25 from '@angular/material/slider';
import * as i26 from '@angular/material/slide-toggle';
import * as i27 from '@angular/material/snack-bar';
import * as i28 from '@angular/material/sort';
import { MatSort, Sort } from '@angular/material/sort';
import * as i29 from '@angular/material/stepper';
import * as i30 from '@angular/material/table';
import * as i31 from '@angular/material/tabs';
import * as i32 from '@angular/material/toolbar';
import * as i33 from '@angular/material/tooltip';
import * as i34 from '@angular/material/tree';
import { DataSource, SelectionModel } from '@angular/cdk/collections';
import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import * as i26$1 from 'ngx-mask';
import * as i5$2 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i6$2 from '@sellan/crypto';

interface ImageTransform {
    scale?: number;
    rotate?: number;
    flipH?: boolean;
    flipV?: boolean;
    translateH?: number;
    translateV?: number;
    translateUnit?: '%' | 'px';
}

interface CropperOptions {
    format: OutputFormat;
    maintainAspectRatio: boolean;
    resetCropOnAspectRatioChange: boolean;
    transform: ImageTransform;
    aspectRatio: number;
    resizeToWidth: number;
    resizeToHeight: number;
    cropperMinWidth: number;
    cropperMinHeight: number;
    cropperMaxHeight: number;
    cropperMaxWidth: number;
    cropperStaticWidth: number;
    cropperStaticHeight: number;
    canvasRotation: number;
    initialStepSize: number;
    roundCropper: boolean;
    onlyScaleDown: boolean;
    imageQuality: number;
    autoCrop: boolean;
    backgroundColor: string;
    containWithinAspectRatio: boolean;
    hideResizeSquares: boolean;
    alignImage: 'left' | 'center';
}
type OutputFormat = 'png' | 'jpeg' | 'bmp' | 'webp' | 'ico';
type OutputType = 'base64' | 'blob';

interface CropperPosition {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
}

interface Dimensions {
    width: number;
    height: number;
}

interface ImageCroppedEvent {
    base64?: string | null;
    blob?: Blob | null;
    objectUrl?: string | null;
    width: number;
    height: number;
    cropperPosition: CropperPosition;
    imagePosition: CropperPosition;
    offsetImagePosition?: CropperPosition;
}

type Position = 'left' | 'topleft' | 'top' | 'topright' | 'right' | 'bottomright' | 'bottom' | 'bottomleft' | 'center';
interface MoveStart {
    active: boolean;
    type: MoveTypes | null;
    position: Position | null;
    transform?: ImageTransform;
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    clientX: number;
    clientY: number;
}
declare enum MoveTypes {
    Drag = "drag",
    Move = "move",
    Resize = "resize",
    Pinch = "pinch"
}

interface ExifTransform {
    rotate: number;
    flip: boolean;
}

interface LoadedImage {
    original: {
        objectUrl: string;
        image: HTMLImageElement;
        size: Dimensions;
    };
    transformed: {
        objectUrl: string;
        image: HTMLImageElement;
        size: Dimensions;
    };
    exifTransform: ExifTransform;
}

declare class CropperSettings {
    format: OutputFormat;
    output: OutputType;
    maintainAspectRatio: boolean;
    transform: ImageTransform;
    aspectRatio: number;
    resetCropOnAspectRatioChange: boolean;
    resizeToWidth: number;
    resizeToHeight: number;
    cropperMinWidth: number;
    cropperMinHeight: number;
    cropperMaxHeight: number;
    cropperMaxWidth: number;
    cropperStaticWidth: number;
    cropperStaticHeight: number;
    canvasRotation: number;
    initialStepSize: number;
    roundCropper: boolean;
    onlyScaleDown: boolean;
    imageQuality: number;
    autoCrop: boolean;
    backgroundColor: string | null;
    containWithinAspectRatio: boolean;
    hideResizeSquares: boolean;
    alignImage: 'left' | 'center';
    cropperFrameAriaLabel: string;
    cropperScaledMinWidth: number;
    cropperScaledMinHeight: number;
    cropperScaledMaxWidth: number;
    cropperScaledMaxHeight: number;
    stepSize: number;
    setOptions(options: Partial<CropperOptions>): void;
    setOptionsFromChanges(changes: SimpleChanges): void;
    private validateOptions;
}

declare class CropService {
    crop(loadedImage: LoadedImage, cropper: CropperPosition, settings: CropperSettings, output: 'blob', maxSize: Dimensions): Promise<ImageCroppedEvent> | null;
    crop(loadedImage: LoadedImage, cropper: CropperPosition, settings: CropperSettings, output: 'base64', maxSize: Dimensions): ImageCroppedEvent | null;
    private cropToBlob;
    private getCanvasTranslate;
    private getRatio;
    private getImagePosition;
    private getOffsetImagePosition;
    getResizeRatio(width: number, height: number, settings: CropperSettings): number;
    getQuality(settings: CropperSettings): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CropService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CropService>;
}

interface BasicEvent {
    clientX: number;
    clientY: number;
}

declare class HammerInput {
    constructor(manager: HammerManager, callback: Function);
    destroy(): void;
    handler(): void;
    init(): void;
    /** Name of the event. Like panstart. */
    type: string;
    /** Movement of the X axis. */
    deltaX: number;
    /** Movement of the Y axis. */
    deltaY: number;
    /** Total time in ms since the first input. */
    deltaTime: number;
    /** Distance moved. */
    distance: number;
    /** Angle moved. */
    angle: number;
    /** Velocity on the X axis, in px/ms. */
    velocityX: number;
    /** Velocity on the Y axis, in px/ms */
    velocityY: number;
    /** Highest velocityX/Y value. */
    velocity: number;
    overallVelocity: number;
    overallVelocityX: number;
    overallVelocityY: number;
    /** Direction moved. Matches the DIRECTION constants. */
    direction: number;
    /** Direction moved from it's starting point. Matches the DIRECTION constants. */
    offsetDirection: number;
    /** Scaling that has been done when multi-touch. 1 on a single touch. */
    scale: number;
    /** Rotation that has been done when multi-touch. 0 on a single touch. */
    rotation: number;
    /** Source event object, type TouchEvent, MouseEvent or PointerEvent. */
    srcEvent: TouchEvent | MouseEvent | PointerEvent;
    /** Target that received the event. */
    target: HTMLElement;
    /** Primary pointer type, could be touch, mouse, pen or kinect. */
    pointerType: string;
    /** true when the first input. */
    isFirst: boolean;
    /** true when the final (last) input. */
    isFinal: boolean;
    /** Array with all pointers, including the ended pointers (touchend, mouseup). */
    pointers: any[];
    /** Array with all new/moved/lost pointers. */
    changedPointers: any[];
    /** Maximum number of pointers detected in the gesture */
    maxPointers: number;
    /** Timestamp of a gesture */
    timeStamp: number;
    /** Reference to the srcEvent.preventDefault() method. Only for experts! */
    preventDefault: Function;
}
interface RecognizerOptions {
    direction?: number | undefined;
    enable?: boolean | ((recognizer: Recognizer, inputData: HammerInput) => boolean) | undefined;
    event?: string | undefined;
    interval?: number | undefined;
    pointers?: number | undefined;
    posThreshold?: number | undefined;
    taps?: number | undefined;
    threshold?: number | undefined;
    time?: number | undefined;
    velocity?: number | undefined;
}
interface Recognizer {
    defaults: any;
    canEmit(): boolean;
    canRecognizeWith(otherRecognizer: Recognizer): boolean;
    dropRecognizeWith(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
    dropRequireFailure(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
    emit(input: HammerInput): void;
    getTouchAction(): any[];
    hasRequireFailures(): boolean;
    process(inputData: HammerInput): string;
    recognize(inputData: HammerInput): void;
    recognizeWith(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
    requireFailure(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
    reset(): void;
    set(options?: RecognizerOptions): Recognizer;
    tryEmit(input: HammerInput): void;
}
interface HammerListener {
    (event: HammerInput): void;
}
/** @docs-private */
interface HammerManager {
    get(recogniser: string): Recognizer;
    on(events: string, handler: HammerListener): void;
}

declare class CropperPositionService {
    resetCropperPosition(sourceImage: ElementRef, cropperPosition: CropperPosition, settings: CropperSettings, maxSize: Dimensions): void;
    move(event: Event | BasicEvent, moveStart: MoveStart, cropperPosition: CropperPosition): void;
    resize(event: Event | BasicEvent | HammerInput, moveStart: MoveStart, cropperPosition: CropperPosition, maxSize: Dimensions, settings: CropperSettings): void;
    checkAspectRatio(position: string, cropperPosition: CropperPosition, maxSize: Dimensions, settings: CropperSettings): void;
    getClientX(event: Event | BasicEvent | TouchEvent | HammerInput): number;
    getClientY(event: Event | BasicEvent | TouchEvent | HammerInput): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CropperPositionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CropperPositionService>;
}

declare class LoadImageService {
    private autoRotateSupported;
    loadImageFile(file: File, cropperSettings: CropperSettings): Promise<LoadedImage>;
    private checkImageTypeAndLoadImageFromArrayBuffer;
    private isValidImageType;
    loadImageFromURL(url: string, cropperSettings: CropperSettings): Promise<LoadedImage>;
    loadBase64Image(imageBase64: string, cropperSettings: CropperSettings): Promise<LoadedImage>;
    private base64ToArrayBuffer;
    private loadImageFromArrayBuffer;
    private getSvgImageSize;
    private transformImageFromArrayBuffer;
    transformLoadedImage(loadedImage: Partial<LoadedImage>, cropperSettings: CropperSettings, forceTransform?: boolean): Promise<LoadedImage>;
    private loadImageFromObjectUrl;
    private getTransformedSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadImageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadImageService>;
}

declare class ImageCropperComponent implements OnChanges, OnInit {
    private cropService;
    private cropperPositionService;
    private loadImageService;
    private sanitizer;
    private cd;
    private zone;
    private readonly hammerLoader;
    hostID: string;
    private settings;
    private setImageMaxSizeRetries;
    private moveStart?;
    private loadedImage?;
    private resizedWhileHidden;
    safeImgDataUrl?: SafeUrl | string;
    safeTransformStyle?: SafeStyle | string;
    marginLeft: SafeStyle | string;
    maxSize: Dimensions;
    moveTypes: typeof MoveTypes;
    imageVisible: boolean;
    wrapper: ElementRef<HTMLDivElement>;
    sourceImage: ElementRef<HTMLDivElement>;
    imageChangedEvent?: Event | null;
    imageURL?: string;
    imageBase64?: string;
    imageFile?: File;
    imageAltText?: string;
    cropperFrameAriaLabel: string;
    output: 'blob' | 'base64';
    format: OutputFormat;
    transform: ImageTransform;
    maintainAspectRatio: boolean;
    aspectRatio: number;
    resetCropOnAspectRatioChange: boolean;
    resizeToWidth: number;
    resizeToHeight: number;
    cropperMinWidth: number;
    cropperMinHeight: number;
    cropperMaxHeight: number;
    cropperMaxWidth: number;
    cropperStaticWidth: number;
    cropperStaticHeight: number;
    canvasRotation: number;
    initialStepSize: number;
    roundCropper: boolean;
    onlyScaleDown: boolean;
    imageQuality: number;
    autoCrop: boolean;
    backgroundColor: string;
    containWithinAspectRatio: boolean;
    hideResizeSquares: boolean;
    allowMoveImage: boolean;
    cropper: CropperPosition;
    alignImage: 'left' | 'center';
    disabled: boolean;
    hidden: boolean;
    imageCropped: EventEmitter<ImageCroppedEvent>;
    startCropImage: EventEmitter<void>;
    imageLoaded: EventEmitter<LoadedImage>;
    cropperReady: EventEmitter<Dimensions>;
    loadImageFailed: EventEmitter<void>;
    transformChange: EventEmitter<ImageTransform>;
    constructor(cropService: CropService, cropperPositionService: CropperPositionService, loadImageService: LoadImageService, sanitizer: DomSanitizer, cd: ChangeDetectorRef, zone: NgZone, hammerLoader: HammerLoader | null);
    ngOnChanges(changes: SimpleChanges): void;
    private onChangesUpdateSettings;
    private onChangesInputImage;
    private isValidImageChangedEvent;
    private setCssTransform;
    ngOnInit(): void;
    private reset;
    private loadImageFile;
    private loadBase64Image;
    private loadImageFromURL;
    private setLoadedImage;
    loadImageError(error: unknown): void;
    imageLoadedInView(): void;
    private checkImageMaxSizeRecursively;
    private sourceImageLoaded;
    onResize(): void;
    private activatePinchGesture;
    private resizeCropperPosition;
    resetCropperPosition(): void;
    keyboardAccess(event: KeyboardEvent): void;
    private changeKeyboardStepSize;
    private keyboardMoveCropper;
    startMove(event: Event | BasicEvent, moveType: MoveTypes, position?: Position | null): void;
    private initMouseMove;
    startPinch(event: HammerInput): void;
    private handleMouseMove;
    onPinch(event: HammerInput): void;
    private setMaxSize;
    private setCropperScaledMinSize;
    private setCropperScaledMinWidth;
    private setCropperScaledMinHeight;
    private setCropperScaledMaxSize;
    private checkCropperPosition;
    private handleMouseUp;
    pinchStop(): void;
    private doAutoCrop;
    crop(): ImageCroppedEvent | null;
    crop(output: 'base64'): ImageCroppedEvent | null;
    crop(output: 'blob'): Promise<ImageCroppedEvent> | null;
    private cropToBlob;
    private cropToBase64;
    private aspectRatioIsCorrect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCropperComponent, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageCropperComponent, "core-cropper", never, { "imageChangedEvent": { "alias": "imageChangedEvent"; "required": false; }; "imageURL": { "alias": "imageURL"; "required": false; }; "imageBase64": { "alias": "imageBase64"; "required": false; }; "imageFile": { "alias": "imageFile"; "required": false; }; "imageAltText": { "alias": "imageAltText"; "required": false; }; "cropperFrameAriaLabel": { "alias": "cropperFrameAriaLabel"; "required": false; }; "output": { "alias": "output"; "required": false; }; "format": { "alias": "format"; "required": false; }; "transform": { "alias": "transform"; "required": false; }; "maintainAspectRatio": { "alias": "maintainAspectRatio"; "required": false; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; }; "resetCropOnAspectRatioChange": { "alias": "resetCropOnAspectRatioChange"; "required": false; }; "resizeToWidth": { "alias": "resizeToWidth"; "required": false; }; "resizeToHeight": { "alias": "resizeToHeight"; "required": false; }; "cropperMinWidth": { "alias": "cropperMinWidth"; "required": false; }; "cropperMinHeight": { "alias": "cropperMinHeight"; "required": false; }; "cropperMaxHeight": { "alias": "cropperMaxHeight"; "required": false; }; "cropperMaxWidth": { "alias": "cropperMaxWidth"; "required": false; }; "cropperStaticWidth": { "alias": "cropperStaticWidth"; "required": false; }; "cropperStaticHeight": { "alias": "cropperStaticHeight"; "required": false; }; "canvasRotation": { "alias": "canvasRotation"; "required": false; }; "initialStepSize": { "alias": "initialStepSize"; "required": false; }; "roundCropper": { "alias": "roundCropper"; "required": false; }; "onlyScaleDown": { "alias": "onlyScaleDown"; "required": false; }; "imageQuality": { "alias": "imageQuality"; "required": false; }; "autoCrop": { "alias": "autoCrop"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "containWithinAspectRatio": { "alias": "containWithinAspectRatio"; "required": false; }; "hideResizeSquares": { "alias": "hideResizeSquares"; "required": false; }; "allowMoveImage": { "alias": "allowMoveImage"; "required": false; }; "cropper": { "alias": "cropper"; "required": false; }; "alignImage": { "alias": "alignImage"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, { "imageCropped": "imageCropped"; "startCropImage": "startCropImage"; "imageLoaded": "imageLoaded"; "cropperReady": "cropperReady"; "loadImageFailed": "loadImageFailed"; "transformChange": "transformChange"; }, never, never, false, never>;
}

declare function provideParentForm(form: NgForm): NgForm;
declare class ProvideParentFormDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ProvideParentFormDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ProvideParentFormDirective, "[provideParentForm]", never, {}, {}, never, never, false, never>;
}

declare class CoreBaseModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreBaseModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreBaseModule, [typeof ProvideParentFormDirective], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4.RouterModule, typeof i5.NgScrollbarModule, typeof i6.CdkTableModule], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4.RouterModule, typeof i5.NgScrollbarModule, typeof i6.CdkTableModule, typeof ProvideParentFormDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreBaseModule>;
}

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

interface DeepmergeOptions {
    arrayMerge?(target: any, source: any, options?: ArrayMergeOptions): any[];
    clone?: boolean;
    customMerge?: (key: string, options?: DeepmergeOptions) => ((x: any, y: any) => any) | undefined;
    isMergeableObject?(value: object): boolean;
}
interface ArrayMergeOptions {
    isMergeableObject(value: object): boolean;
    cloneUnlessOtherwiseSpecified(value: object, options?: DeepmergeOptions): object;
}

declare class Deepmerge {
    private static emptyTarget;
    private static cloneUnlessOtherwiseSpecified;
    private static defaultArrayMerge;
    private static getMergeFunction;
    private static getEnumerableOwnPropertySymbols;
    private static getKeys;
    private static propertyIsOnObject;
    private static propertyIsUnsafe;
    private static mergeObject;
    static deepmerge(target: any, source: any, options: DeepmergeOptions): any;
    static all(array: object[], options?: DeepmergeOptions): object;
}

declare const dateReviver: (_key: string, value: any) => any;
declare const rehydrateApplicationState: (keys: Keys, storage: Storage, storageKeySerializer: (key: string) => string, restoreDates: boolean) => any;
declare const syncStateUpdate: (state: any, keys: Keys, storage: Storage, storageKeySerializer: (key: string | number) => string, removeOnUndefined: boolean, syncCondition?: (state: any) => any) => void;
declare const defaultMergeReducer: (state: any, rehydratedState: any, action: any) => any;
declare const localStorageSync: (config: LocalStorageConfig) => (reducer: any) => (state: any, action: any) => any;
interface IKeyConfiguration {
    [key: string]: string[] | number[] | IKeyConfiguration[] | IOptions | ((key: string, value: any) => any);
}
interface IOptions {
    serialize?: (state: any) => any;
    deserialize?: (state: any) => any;
    reviver?: (key: string, value: any) => any;
    replacer?: ((key: string, value: any) => any) | string[];
    encrypt?: (message: string) => string;
    decrypt?: (message: string) => string;
    filter?: string[];
    space?: string | number;
}
type Keys = (IKeyConfiguration | IOptions | string)[];
interface LocalStorageConfig {
    keys: Keys;
    rehydrate?: boolean;
    storage?: Storage;
    removeOnUndefined?: boolean;
    restoreDates?: boolean;
    storageKeySerializer?: (key: string) => string;
    syncCondition?: (state: any) => any;
    checkStorageAvailability?: boolean;
    mergeReducer?: (state: any, rehydratedState: any, action: any) => any;
}

type MatTimePeriodType = 'am' | 'pm';
declare class MatTimePeriod {
    /** Whether the time period is vertically aligned. */
    get vertical(): boolean;
    set vertical(value: BooleanInput);
    private _vertical;
    get period(): MatTimePeriodType;
    set period(value: MatTimePeriodType);
    private _period;
    get disabledPeriod(): MatTimePeriodType | null;
    set disabledPeriod(value: MatTimePeriodType | null);
    private _disabledPeriod;
    periodChanged: EventEmitter<MatTimePeriodType>;
    setPeriod(event: Event, period: MatTimePeriodType): void;
    _isPeriodDisabled(period: MatTimePeriodType): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimePeriod, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimePeriod, "mat-time-period", never, { "vertical": { "alias": "vertical"; "required": false; }; "period": { "alias": "period"; "required": false; }; "disabledPeriod": { "alias": "disabledPeriod"; "required": false; }; }, { "periodChanged": "periodChanged"; }, never, never, false, never>;
}

/** InjectionToken for timepicker that can be used to override default locale code. */
declare const MAT_TIME_LOCALE: InjectionToken<string>;
declare function MAT_DATE_TIME_LOCALE_FACTORY(): string;
/**
 * No longer needed since MAT_TIME_LOCALE has been changed to a scoped injectable.
 * If you are importing and providing this in your code you can simply remove it.
 * @deprecated
 * @breaking-change 18.0.0
 */
declare const MAT_TIME_LOCALE_PROVIDER: {
    provide: InjectionToken<string>;
    useExisting: InjectionToken<string>;
};
declare abstract class TimeAdapter<T, L = any> {
    /** The locale to use for time. */
    protected locale: L;
    /**
     * Gets now's time.
     * @returns Now's time.
     */
    abstract now(): T;
    /**
     * Parses a time from a user-provided value.
     * @param value The value to parse.
     * @param parseFormat The expected format of the value being parsed
     *     (type is implementation-dependent).
     * @returns The parsed time.
     */
    abstract parse(value: any, parseFormat: any): T | null;
    /**
     * Gets the hour component of the given time.
     * @param time The time to extract the hour from.
     * @returns The hour component.
     */
    abstract getHour(time: T): number;
    /**
     * Gets the minute component of the given time.
     * @param time The time to extract the minute from.
     * @returns The minute component.
     */
    abstract getMinute(time: T): number;
    /**
     * Update the hour component of the given time.
     * @param time The time to update the hour.
     * @param hour The new hour to update given time.
     * @returns The new time with updated hour component.
     */
    abstract updateHour(time: T, hour: number): T;
    /**
     * Update the minute component of the given time.
     * @param time The time to update the minute.
     * @param minute The new minute to update given time.
     * @returns The new time with updated minute component.
     */
    abstract updateMinute(time: T, minute: number): T;
    /**
     * Gets the period component of the given time.
     * @param time The time to extract the period from.
     * @returns The period component.
     */
    abstract getPeriod(time: T): MatTimePeriodType;
    /**
     * Formats a time as a string according to the given format.
     * @param time The value to format.
     * @param displayFormat The format to use to display the time as a string.
     * @returns The formatted time string.
     */
    abstract format(time: T, displayFormat: any): string;
    /**
     * Checks whether the given object is considered a time instance by this timeAdapter.
     * @param obj The object to check
     * @returns Whether the object is a time instance.
     */
    abstract isTimeInstance(obj: any): boolean;
    /**
     * Checks whether the given time is valid.
     * @param time The time to check.
     * @returns Whether the time is valid.
     */
    abstract isValid(time: T): boolean;
    /**
     * Gets time instance that is not valid.
     * @returns An invalid time.
     */
    abstract invalid(): T;
    /**
     * Given a potential time object, returns that same time object if it is
     * a valid time, or `null` if it's not a valid time.
     * @param obj The object to check.
     * @returns A time or `null`.
     */
    getValidTimeOrNull(obj: unknown): T | null;
    /**
     * Attempts to deserialize a value to a valid time object. The `<mat-timepicker>` will call this
     * method on all of its `@Input()` properties that accept time. It is therefore possible to
     * support passing values from your backend directly to these properties by overriding this method
     * to also deserialize the format used by your backend.
     * @param value The value to be deserialized into a time object.
     * @returns The deserialized time object, either a valid time, null if the value can be
     *     deserialized into a null time (e.g. the empty string), or an invalid date.
     */
    deserialize(value: any): T | null;
    /**
     * Sets the locale used for all time.
     * @param locale The new locale.
     */
    setLocale(locale: L): void;
    /**
     * Compares two time.
     * @param first The first time to compare.
     * @param second The second time to compare.
     * @returns 0 if the time are equal, a number less than 0 if the first time is earlier,
     *     a number greater than 0 if the first time is later.
     */
    abstract compareTime(first: T, second: T): number;
    /**
     * Checks if two time are equal.
     * @param first The first time to check.
     * @param second The second time to check.
     * @returns Whether the two time are equal.
     *     Null time are considered equal to other null time.
     */
    sameTime(first: T | null, second: T | null): boolean;
    /**
     * Clamp the given time between min and max time.
     * @param time The time to clamp.
     * @param min The minimum value to allow. If null or omitted no min is enforced.
     * @param max The maximum value to allow. If null or omitted no max is enforced.
     * @returns `min` if `time` is less than `min`, `max` if time is greater than `max`,
     *     otherwise `time`.
     */
    clampTime(time: T, min?: T | null, max?: T | null): T;
}

/** Adapts the native JS Date for components that work with time. */
declare class NativeDateTimeAdapter extends TimeAdapter<Date> {
    private readonly _matTimeLocale;
    constructor(matTimeLocale: string);
    now(): Date;
    parse(value: any, parseFormat?: any): Date | null;
    parseTime(value: string): {
        hour: number;
        minute: number;
        meridiem?: 'am' | 'pm';
    };
    getHour(date: Date): number;
    getMinute(date: Date): number;
    updateHour(date: Date, hour: number): Date;
    updateMinute(date: Date, minute: number): Date;
    getPeriod(date: Date): MatTimePeriodType;
    format(date: Date, displayFormat: Object): string;
    /**
     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
     * invalid date for all other values.
     */
    deserialize(value: any): Date | null;
    isTimeInstance(obj: any): boolean;
    isValid(date: Date): boolean;
    invalid(): Date;
    compareTime(first: Date, second: Date): number;
    /**
     * When converting Date object to string, javascript built-in functions may return wrong
     * results because it applies its internal DST rules. The DST rules around the world change
     * very frequently, and the current valid rule is not always valid in previous years though.
     * We work around this problem building a new Date object which has its internal UTC
     * representation with the local date and time.
     * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have
     *    timeZone set to 'utc' to work fine.
     * @param date Date from which we want to get the string representation according to dtf
     * @returns A Date object with its UTC representation based on the passed in date info
     */
    private _format;
    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateTimeAdapter, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NativeDateTimeAdapter>;
}

declare class NativeDateTimeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateTimeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NativeDateTimeModule, never, [typeof i1.PlatformModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NativeDateTimeModule>;
}
declare class MatNativeDateTimeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MatNativeDateTimeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MatNativeDateTimeModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MatNativeDateTimeModule>;
}
declare function provideNativeDateTimeAdapter(): Provider;

type ExtractTimeTypeFromSelection<T> = NonNullable<T>;
/**
 * Event emitted by the time selection model when its selection changes.
 * @docs-private
 */
interface TimeSelectionModelChange<S> {
    /** New value for the selection. */
    selection: S;
    /** Object that triggered the change. */
    source: unknown;
    /** Previous value */
    oldValue?: S;
}
/**
 * A selection model containing a time selection.
 */
declare abstract class MatTimeSelectionModel<S, T = ExtractTimeTypeFromSelection<S>> implements OnDestroy {
    protected _adapter: TimeAdapter<T>;
    /** The current selection. */
    readonly selection: S;
    private readonly _selectionChanged;
    /** Emits when the selection has changed. */
    selectionChanged: Observable<TimeSelectionModelChange<S>>;
    /**
     * Updates the current selection in the model.
     * @param value New selection that should be assigned.
     * @param source Object that triggered the selection change.
     */
    updateSelection(value: S, source: unknown): void;
    protected constructor(_adapter: TimeAdapter<T>);
    ngOnDestroy(): void;
    /** Adds a time to the current selection. */
    abstract add(time: T | null): void;
    /** Clones the selection model. */
    abstract clone(): MatTimeSelectionModel<S, T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimeSelectionModel<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MatTimeSelectionModel<any, any>>;
}

declare class MatTimepickerIntl {
    /** A label for inputs title. */
    inputsTitle: string;
    /** A label for dials title. */
    dialsTitle: string;
    /** A label for hour input hint. */
    hourInputHint: string;
    /** A label for minute input hint. */
    minuteInputHint: string;
    /** Label for the button used to open the timepicker popup (used by screen readers). */
    openTimepickerLabel: string;
    /** Label for the button used to close the timepicker popup (used by screen readers). */
    closeTimepickerLabel: string;
    /** A label for OK button to apply time. */
    okButton: string;
    /** A label for cancel button to close timepicker. */
    cancelButton: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MatTimepickerIntl>;
}

declare abstract class MatTimeFaceBase<T> implements AfterContentInit, AfterViewChecked {
    protected _timeAdapter: TimeAdapter<T>;
    /** The currently selected time. */
    get selected(): T | null;
    set selected(value: T | null);
    private _selected;
    /** The minimum selectable time. */
    get minTime(): T | null;
    set minTime(value: T | null);
    private _minTime;
    /** The maximum selectable time. */
    get maxTime(): T | null;
    set maxTime(value: T | null);
    private _maxTime;
    /** Step over minutes. */
    get minuteInterval(): number;
    set minuteInterval(value: number);
    private _minuteInterval;
    /** Whether the clock uses 12 hour format. */
    isMeridiem: boolean;
    /** Color palette. */
    color: ThemePalette;
    /** Emits when any hour, minute or period is selected. */
    _userSelection: EventEmitter<T>;
    selectedChange: EventEmitter<T>;
    selectedHour: number;
    selectedMinute: number;
    period: MatTimePeriodType;
    disabledPeriod: MatTimePeriodType | null;
    availableMinutes: number[];
    availableHours: number[];
    /**
     * Used for scheduling that focus should be moved to the active cell on the next tick.
     * We need to schedule it, rather than do it immediately, because we have to wait
     * for Angular to re-evaluate the view children.
     */
    private _moveFocusOnNextTick;
    constructor(_timeAdapter: TimeAdapter<T>);
    ngAfterContentInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Focuses the active cell after or input the microtask queue is empty.
     *
     * Adding a 0ms setTimeout seems to fix Voiceover losing focus when pressing PageUp/PageDown.
     *
     * Determined a 0ms by gradually increasing duration from 0 and testing two use cases with screen
     * reader enabled:
     *
     * 1. Pressing PageUp/PageDown repeatedly with pausing between each key press.
     * 2. Pressing and holding the PageDown key with repeated keys enabled.
     *
     * Test 1 worked roughly 95-99% of the time with 0ms and got a little bit better as the duration
     * increased. Test 2 got slightly better until the duration was long enough to interfere with
     * repeated keys. If the repeated key speed was faster than the timeout duration, then pressing
     * and holding pagedown caused the entire page to scroll.
     *
     * Since repeated key speed can verify across machines, determined that any duration could
     * potentially interfere with repeated keys. 0ms would be best because it almost entirely
     * eliminates the focus being lost in Voiceover without causing unintended side effects.
     * Adding delay also complicates writing tests.
     */
    abstract focusActiveCell(): void;
    /** Handles hour selection. */
    _onHourSelected(hour: number): void;
    /** Handles minute selection. */
    _onMinuteSelected(minute: number): void;
    /** Handles period changing. */
    _onPeriodChanged(period: MatTimePeriodType): void;
    _getAvailableHours(): number[];
    _onKeydown(event: KeyboardEvent, view: 'hour' | 'minute'): void;
    private _handleHourKeydown;
    private _handleMinuteKeydown;
    /** Gets a correct hours based on meridiem and period. */
    private _getHourBasedOnPeriod;
    private _timeSelected;
    /** Sets min hour. */
    private _setMinHour;
    /** Sets max hour. */
    private _setMaxHour;
    /** Sets min minute. */
    private _setMinMinute;
    /** Sets max minute. */
    private _setMaxMinute;
    /** Sets disabled period. */
    private _setDisabledPeriod;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimeFaceBase<any>, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimeFaceBase<any>, never, never, { "selected": { "alias": "selected"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "minuteInterval": { "alias": "minuteInterval"; "required": false; }; "isMeridiem": { "alias": "isMeridiem"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "_userSelection": "_userSelection"; "selectedChange": "selectedChange"; }, never, never, true, never>;
}

/** Possible options for the timepicker orientation (dial mode only). */
type TimepickerOrientation = 'horizontal' | 'vertical';

type MatDialView = 'hours' | 'minutes';
declare class MatClockDials<T> extends MatTimeFaceBase<T> implements OnInit, OnDestroy {
    _intl: MatTimepickerIntl;
    private _ngZone;
    private _elementRef;
    private _cdr;
    /** Layout orientation. */
    orientation: TimepickerOrientation;
    isHoursView: boolean;
    /** Specifies the view of clock dial. */
    private readonly _view;
    private _viewSubscription;
    constructor(_intl: MatTimepickerIntl, _timeAdapter: TimeAdapter<T>, _ngZone: NgZone, _elementRef: ElementRef, _cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /** Changes clock dial view. */
    onViewChange(event: Event, view: MatDialView): void;
    focusActiveCell(): void;
    _withZeroPrefix(value: number): string;
    _onMinuteSelected(minute: number): void;
    /** Handles hour selection. */
    _onHourChanged({ hour, changeView, }: {
        hour: number;
        changeView?: boolean;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatClockDials<any>, [null, { optional: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatClockDials<any>, "mat-clock-dials", ["matClockDials"], { "orientation": { "alias": "orientation"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class MatTimeInputBase {
    private element;
    private _cdr;
    private _document;
    get value(): number;
    set value(value: number);
    private _value;
    timeChanged: EventEmitter<number>;
    _keydown(event: KeyboardEvent): void;
    get inputElement(): HTMLInputElement;
    get hasFocus(): boolean;
    constructor(element: ElementRef<HTMLInputElement>, _cdr: ChangeDetectorRef, _document: Document);
    focus(): void;
    blur(): void;
    setInputValue(value: number | null): void;
    setInputPlaceholder(value: number): void;
    abstract _withZeroPrefix(value: number): string;
    abstract _formatValue(value: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimeInputBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimeInputBase, never, never, { "value": { "alias": "value"; "required": false; }; }, { "timeChanged": "timeChanged"; }, never, never, true, never>;
}

declare class MatHourInput extends MatTimeInputBase {
    get availableHours(): number[];
    set availableHours(value: number[]);
    private _availableHours;
    isMeridiem: boolean;
    constructor(element: ElementRef<HTMLInputElement>, _cdr: ChangeDetectorRef, _document: Document);
    _withZeroPrefix(value: number): string;
    _formatValue(hour: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatHourInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatHourInput, "input[matHourInput]", ["matTimeInput"], { "availableHours": { "alias": "availableHours"; "required": false; }; "isMeridiem": { "alias": "isMeridiem"; "required": false; }; }, {}, never, never, false, never>;
}
declare class MatMinuteInput extends MatTimeInputBase {
    /** Step over minutes. */
    get interval(): number;
    set interval(value: number);
    private _interval;
    get availableMinutes(): number[];
    set availableMinutes(value: number[]);
    private _availableMinutes;
    constructor(element: ElementRef<HTMLInputElement>, _cdr: ChangeDetectorRef, _document: Document);
    _withZeroPrefix(value: number): string;
    _formatValue(value: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMinuteInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatMinuteInput, "input[matMinuteInput]", ["matTimeInput"], { "interval": { "alias": "interval"; "required": false; }; "availableMinutes": { "alias": "availableMinutes"; "required": false; }; }, {}, never, never, false, never>;
}
declare class MatTimeInputs<T> extends MatTimeFaceBase<T> {
    _intl: MatTimepickerIntl;
    private _ngZone;
    private _elementRef;
    constructor(_intl: MatTimepickerIntl, _timeAdapter: TimeAdapter<T>, _ngZone: NgZone, _elementRef: ElementRef);
    /**
     * Using for skipping that focus shouldn't be moved to the active cell on the next tick.
     * We need to use it to avoid focusing input for input mode.
     */
    private _skipNextTickFocus;
    focusActiveCell(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimeInputs<any>, [null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimeInputs<any>, "mat-time-inputs", never, {}, {}, never, never, false, never>;
}

declare class MatTimepickerContent<S, T = ExtractTimeTypeFromSelection<S>> implements OnInit, AfterViewInit {
    private _globalModel;
    private _changeDetectorRef;
    /** Reference to the internal clock dials component. */
    _dials: MatClockDials<T> | undefined;
    /** Reference to the internal time inputs component. */
    _inputs: MatTimeInputs<T> | undefined;
    /** Reference to the timepicker that created the overlay. */
    timepicker: MatTimepickerBase<any, S, T>;
    /** Display mode. */
    mode: TimepickerMode;
    /** Current state of the animation. */
    _animationState: 'enter-dropdown' | 'enter-dialog' | 'void';
    /** Whether the clock uses 12 hour format. */
    isMeridiem: boolean;
    /** Whether should toggle face button be shown. */
    showToggleModeButton: boolean;
    /** Step for minutes. */
    minuteInterval: number;
    /** Orientation for dial mode. */
    orientation: TimepickerOrientation;
    /** Portal with projected action buttons. */
    _actionsPortal: TemplatePortal | ComponentPortal<any> | null;
    /** Id of the label for the `role="dialog"` element. */
    _dialogLabelId: string | null;
    /** Text for the close button. */
    _closeButtonText: string;
    /** Whether the close button currently has focus. */
    _closeButtonFocused: boolean;
    /** Whether there is an in-progress animation. */
    _isAnimating: boolean;
    /** Emits when an animation has finished. */
    readonly _animationDone: Subject<void>;
    private _model;
    private _subscriptions;
    constructor(elementRef: ElementRef, intl: MatTimepickerIntl, _globalModel: MatTimeSelectionModel<S, T>, _changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /** Changes animation state while closing timepicker content. */
    _startExitAnimation(): void;
    _handleAnimationEvent(event: AnimationEvent): void;
    onToggleMode(mode: TimepickerMode): void;
    _getSelected(): T | null;
    /** Applies the current pending selection to the global model. */
    _applyPendingSelection(): void;
    /**
     * Assigns a new portal containing the timepicker actions.
     * @param portal Portal with the actions to be assigned.
     * @param forceRerender Whether a re-render of the portal should be triggered. This isn't
     * necessary if the portal is assigned during initialization, but it may be required if it's
     * added at a later point.
     */
    _assignActions(portal: TemplatePortal<any> | ComponentPortal<any> | null, forceRerender: boolean): void;
    _handleUserSelection(event: T): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerContent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerContent<any, any>, "mat-timepicker-content", ["matTimepickerContent"], {}, {}, never, never, false, never>;
}

/** Possible options for the timepicker to open. */
type TimepickerOpenAs = 'dialog' | 'popup';
/** Possible positions for the timepicker dropdown along the X axis. */
type TimepickerDropdownPositionX = 'start' | 'end';
/** Possible positions for the timepicker dropdown along the Y axis. */
type TimepickerDropdownPositionY = 'above' | 'below';
/** Possible options for the timepicker to display. */
type TimepickerMode = 'input' | 'dial';
/** Possible options for the timepicker period format. */
type TimepickerFormat = '12h' | '24h';
/** Form control that can be associated with a timepicker. */
interface MatTimepickerControl<T> {
    disabled: boolean;
    min: T | null;
    max: T | null;
    stateChanges: Observable<void>;
    getThemePalette(): ThemePalette;
    getConnectedOverlayOrigin(): ElementRef;
    getOverlayLabelId(): string | null;
}
/** A timepicker that can be attached to a {@link MatTimepickerControl}. */
interface MatTimepickerPanel<C extends MatTimepickerControl<T>, S, T = ExtractTimeTypeFromSelection<S>> {
    /** Stream that emits whenever the timepicker is opened. */
    openedStream: EventEmitter<void>;
    /** Stream that emits whenever the timepicker is closed. */
    closedStream: EventEmitter<void>;
    /** Emits when the timepicker's state changes. */
    stateChanges: Subject<void>;
    /** Register an input with the timeepicker. */
    registerInput(input: C): MatTimeSelectionModel<S, T>;
}
/**
 * Represents the default options for the form field that can be configured
 * using the `MAT_TIMEPICKER_DEFAULT_OPTIONS` injection token.
 */
interface MatTimepickerDefaultOptions {
    /** Default color of the timepicker. */
    color?: ThemePalette;
    /** Default timepicker mode. */
    mode: TimepickerMode;
    /** Defines how timepicker will be appeared. */
    openAs: TimepickerOpenAs;
    /** Default timepicker format. */
    format: TimepickerFormat;
    /** Should toggle face button be visible. */
    showToggleModeButton: boolean;
    /** Step for minutes. */
    minuteInterval: number;
    /** Orientation for dial mode. */
    orientation: TimepickerOrientation;
}
/**
 * Injection token that can be used to configure the
 * default options for all timepickers within an app.
 */
declare const MAT_TIMEPICKER_DEFAULT_OPTIONS: InjectionToken<MatTimepickerDefaultOptions>;
declare abstract class MatTimepickerBase<C extends MatTimepickerControl<T>, S, T = ExtractTimeTypeFromSelection<S>> implements OnChanges {
    private _viewContainerRef;
    private _overlay;
    private _ngZone;
    private _defaultActionsComponent;
    private _model;
    private _defaults?;
    /** Whether the timepicker pop-up should be disabled. */
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    private _disabled;
    /** Whether the timepicker is open. */
    get opened(): boolean;
    set opened(value: BooleanInput);
    private _opened;
    /** Whether the timepicker mode which determines what the timepicker will be opened as. */
    get openAs(): TimepickerOpenAs;
    set openAs(value: TimepickerOpenAs);
    private _openAs;
    /** Color palette to use on the timepicker's content. */
    get color(): ThemePalette;
    set color(value: ThemePalette);
    private _color;
    /** Timepicker display mode. */
    get mode(): TimepickerMode;
    set mode(value: TimepickerMode);
    private _mode;
    /** Timepicker period format. */
    get format(): TimepickerFormat;
    set format(value: TimepickerFormat);
    private _format;
    /** Show or hide toggle button between dial and input. */
    get showToggleModeButton(): boolean;
    set showToggleModeButton(value: boolean);
    private _showToggleModeButton;
    /** Step for minutes. */
    get minuteInterval(): number;
    set minuteInterval(value: number);
    private _minuteInterval;
    /** Orientation for dial mode. */
    get orientation(): TimepickerOrientation;
    set orientation(value: TimepickerOrientation);
    private _orientation;
    /** Preferred position of the timepicker in the X axis. */
    xPosition: TimepickerDropdownPositionX;
    /** Preferred position of the timepicker in the Y axis. */
    yPosition: TimepickerDropdownPositionY;
    /**
     * Whether to restore focus to the previously-focused element when the timepicker is closed.
     * Note that automatic focus restoration is an accessibility feature and it is recommended that
     * you provide your own equivalent, if you decide to turn it off.
     */
    get restoreFocus(): boolean;
    set restoreFocus(value: BooleanInput);
    private _restoreFocus;
    /** Emits when the timepicker has been opened. */
    readonly openedStream: EventEmitter<void>;
    /** Emits when the timepicker has been closed. */
    readonly closedStream: EventEmitter<void>;
    /** The id for the timepicker. */
    id: string;
    /** The input element this timepicker is associated with. */
    timepickerInput: C;
    /** Portal with projected action buttons. */
    _actionsPortal: TemplatePortal | null;
    /** Emits when the timepicker's state changes. */
    readonly stateChanges: Subject<void>;
    /** A reference to the overlay into which we've rendered the timepicker. */
    private _overlayRef;
    /** Reference to the component instance rendered in the overlay. */
    private _componentRef;
    /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */
    private _backdropHarnessClass;
    /** The element that was focused before the timepicker was opened. */
    private _focusedElementBeforeOpen;
    private _document;
    /** Scroll strategy. */
    private _scrollStrategy;
    /** The minimum selectable time. */
    _getMinTime(): T | null;
    /** The maximum selectable time. */
    _getMaxTime(): T | null;
    constructor(_viewContainerRef: ViewContainerRef, _overlay: Overlay, _ngZone: NgZone, scrollStrategy: any, _defaultActionsComponent: ComponentType<any>, _model: MatTimeSelectionModel<S, T>, _defaults?: MatTimepickerDefaultOptions);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /** Opens the timepicker. */
    open(): void;
    /** Closes the timepicker. */
    close(): void;
    /**
     * Register an input with this timepicker.
     * @param input The timepicker input to register with this timepicker.
     * @returns Selection model that the input should hook itself up to.
     */
    registerInput(input: C): MatTimeSelectionModel<S, T>;
    /**
     * Registers a portal containing action buttons with the timepicker.
     * @param portal Portal to be registered.
     */
    registerActions(portal: TemplatePortal): void;
    /**
     * Removes a portal containing action buttons from the timepicker.
     * @param portal Portal to be removed.
     */
    removeActions(portal: TemplatePortal): void;
    /** Applies the current pending selection on the overlay to the model. */
    _applyPendingSelection(): void;
    /** Forwards relevant values from the timepicker to the timepicker content inside the overlay. */
    protected _forwardContentValues(instance: MatTimepickerContent<S, T>): void;
    /** Opens the overlay with the timepicker. */
    private _openOverlay;
    /** Destroys the current overlay. */
    private _destroyOverlay;
    /** Gets a position strategy that will open the timepicker as a dropdown. */
    private _getDialogStrategy;
    /** Gets a position strategy that will open the timepicker as a dropdown. */
    private _getDropdownStrategy;
    /** Sets the positions of the timepicker in dropdown mode based on the current configuration. */
    private _setConnectedPositions;
    /** Gets an observable that will emit when the overlay is supposed to be closed. */
    private _getCloseStream;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerBase<any, any, any>, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerBase<any, any, any>, never, never, { "disabled": { "alias": "disabled"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "openAs": { "alias": "openAs"; "required": false; }; "color": { "alias": "color"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "format": { "alias": "format"; "required": false; }; "showToggleModeButton": { "alias": "showToggleModeButton"; "required": false; }; "minuteInterval": { "alias": "minuteInterval"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; }, { "openedStream": "opened"; "closedStream": "closed"; }, never, never, true, never>;
}

declare class MatTimepicker<T> extends MatTimepickerBase<MatTimepickerControl<T>, T | null, T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepicker<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepicker<any>, "mat-timepicker", ["matTimepicker"], {}, {}, never, never, false, never>;
}

declare class MatTimepickerToggleIcon {
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerToggleIcon, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerToggleIcon, "[matTimepickerToggleIcon]", never, {}, {}, never, never, false, never>;
}
declare class MatTimepickerToggle<T> implements OnChanges, OnDestroy {
    _intl: MatTimepickerIntl;
    private _cdr;
    /** Timepicker instance. */
    timepicker: MatTimepicker<T>;
    /** Whether the toggle button is disabled. */
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    private _disabled;
    /** Whether ripples on the toggle should be disabled. */
    disableRipple: boolean;
    /** Tabindex for the toggle. */
    tabIndex: number | null;
    /** Custom icon set by the consumer. */
    customIcon: MatTimepickerToggleIcon;
    /** Screen-reader label for the button. */
    ariaLabel: string;
    private _stateChanges;
    constructor(defaultTabIndex: string, _intl: MatTimepickerIntl, _cdr: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /** Opens timepicker. */
    open(event: Event): void;
    private _watchStateChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerToggle<any>, [{ attribute: "tabindex"; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerToggle<any>, "mat-timepicker-toggle", ["matTimepickerToggle"], { "timepicker": { "alias": "for"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; }, {}, ["customIcon"], ["[matTimepickerToggleIcon]"], false, never>;
}

declare class MatTimepickerContentLayout {
    /** Content title. */
    title: string;
    /** Layout orientation. */
    orientation: TimepickerOrientation;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerContentLayout, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerContentLayout, "mat-timepicker-content-layout", ["matTimepickerContent"], { "title": { "alias": "title"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, {}, never, ["[hours]", "[minutes]", "[mat-time-period]", "*"], false, never>;
}

/**
 * An event used for timepicker input and change events. We don't always have access to a native
 * input or change event because the event may have been triggered by the user clicking on the
 * clock popup. For consistency, we always use MatTimepickerInputEvent instead.
 */
declare class MatTimepickerInputEvent<D, S = unknown> {
    /** Reference to the timepicker input component that emitted the event. */
    target: MatTimepickerInputBase<S, D>;
    /** Reference to the native input element associated with the timepicker input. */
    targetElement: HTMLElement;
    /** The new value for the target timepicker input. */
    value: D | null;
    constructor(
    /** Reference to the timepicker input component that emitted the event. */
    target: MatTimepickerInputBase<S, D>, 
    /** Reference to the native input element associated with the timepicker input. */
    targetElement: HTMLElement);
}
declare abstract class MatTimepickerInputBase<S, T = ExtractTimeTypeFromSelection<S>> implements OnChanges, OnDestroy, ControlValueAccessor, Validator {
    protected _elementRef: ElementRef<HTMLInputElement>;
    _timeAdapter: TimeAdapter<T>;
    /** The value of the input. */
    get value(): T | null;
    set value(value: any);
    protected _model: MatTimeSelectionModel<S, T> | undefined;
    /** Whether the timepicker-input is disabled. */
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    private _disabled;
    /** Emits when a change event is fired on this <input>. */
    readonly timeChange: EventEmitter<MatTimepickerInputEvent<T, S>>;
    /** Emits when an input event is fired on this <input>. */
    readonly timeInput: EventEmitter<MatTimepickerInputEvent<T, S>>;
    /** Gets the minimum time for the input. Used for validation. */
    abstract _getMinTime(): T | null;
    /** Gets the maximum time for the input. Used for validation. */
    abstract _getMaxTime(): T | null;
    /** Combined form control validator for this input. */
    protected abstract _validator: ValidatorFn | null;
    /** Whether the component has been initialized. */
    private _isInitialized;
    /**
     * Since the value is kept on the model which is assigned in an Input,
     * we might get a value before we have a model. This property keeps track
     * of the value until we have somewhere to assign it.
     */
    private _pendingValue;
    /** Emits when the internal state has changed */
    readonly stateChanges: Subject<void>;
    _onTouched: () => void;
    _validatorOnChange: () => void;
    private _cvaOnChange;
    private _valueChangesSubscription;
    constructor(_elementRef: ElementRef<HTMLInputElement>, _timeAdapter: TimeAdapter<T>);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /** Registers a time selection model with the input. */
    _registerModel(model: MatTimeSelectionModel<S, T>): void;
    _onInput(value: string): void;
    /** Handles change event on the input. */
    _onChange(): void;
    /** Handles blur event on the input. */
    _onBlur(): void;
    /** Implemented as part of ControlValueAccessor.  */
    writeValue(value: T | null): void;
    /** Implemented as part of ControlValueAccessor.  */
    registerOnChange(fn: any): void;
    /** Implemented as part of ControlValueAccessor.  */
    registerOnTouched(fn: () => void): void;
    /** Implemented as part of ControlValueAccessor.  */
    setDisabledState?(isDisabled: boolean): void;
    registerOnValidatorChange(fn: () => void): void;
    validate(c: AbstractControl): ValidationErrors | null;
    /** Whether the last value set on the input was valid. */
    protected _lastValueValid: boolean;
    /** Assigns a value to the input's model. */
    protected abstract _assignValueToModel(model: T | null): void;
    /** Converts a value from the model into a native value for the input. */
    protected abstract _getValueFromModel(modelValue: S): T | null;
    /** Predicate that determines whether the input should handle a particular change event. */
    protected abstract _shouldHandleChangeEvent(event: TimeSelectionModelChange<S>): boolean;
    /** Programmatically assigns a value to the input. */
    protected _assignValueProgrammatically(value: T | null): void;
    /** Formats a value and sets it on the input element. */
    protected _formatValue(value: T | null): void;
    /** Gets the base validator functions. */
    protected _getValidators(): ValidatorFn[];
    /** Whether a value is considered valid. */
    private _isValidValue;
    /** Assigns a value to the model. */
    private _assignValue;
    /** The form control validator for whether the input parses. */
    private _parseValidator;
    /** The form control validator for the min time. */
    private _minValidator;
    /** The form control validator for the max time. */
    private _maxValidator;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerInputBase<any, any>, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerInputBase<any, any>, never, never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "timeChange": "timeChange"; "timeInput": "timeInput"; }, never, never, true, never>;
}
/**
 * Checks whether the `SimpleChanges` object from an `ngOnChanges`
 * callback has any changes, accounting for time objects.
 */
declare function timeInputsHaveChanged(changes: SimpleChanges, adapter: TimeAdapter<unknown>): boolean;

declare const MAT_TIMEPICKER_VALUE_ACCESSOR: any;
declare const MAT_TIMEPICKER_VALIDATORS: any;
/** Directive used to connect an input to a MatTimepicker. */
declare class MatTimepickerInput<T> extends MatTimepickerInputBase<T | null, T> implements MatTimepickerControl<T | null> {
    private _formField?;
    /** The timepicker that this input is associated with. */
    set matTimepicker(timepicker: MatTimepickerPanel<MatTimepickerControl<T>, T | null, T>);
    _timepicker: MatTimepickerPanel<MatTimepickerControl<T>, T | null, T>;
    /** The combined form control validator for this input. */
    protected _validator: ValidatorFn | null;
    /** The minimum valid date. */
    get min(): T | null;
    set min(value: T | null);
    private _min;
    /** The maximum valid date. */
    get max(): T | null;
    set max(value: T | null);
    private _max;
    constructor(elementRef: ElementRef<HTMLInputElement>, timeAdapter: TimeAdapter<T>, _formField?: MatFormField);
    /**
     * Gets the element that the timepicker popup should be connected to.
     * @return The element to connect the popup to.
     */
    getConnectedOverlayOrigin(): ElementRef;
    /** Returns the palette used by the input's form field, if any. */
    getThemePalette(): ThemePalette;
    /** Gets the ID of an element that should be used a description for the timepicker overlay. */
    getOverlayLabelId(): string | null;
    /** Gets the input's minimum time. */
    _getMinTime(): T;
    /** Gets the input's maximum time. */
    _getMaxTime(): T;
    protected _assignValueToModel(value: T | null): void;
    protected _getValueFromModel(modelValue: T | null): T | null;
    protected _shouldHandleChangeEvent(event: TimeSelectionModelChange<T>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerInput<any>, [null, { optional: true; }, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerInput<any>, "input[matTimepicker]", ["matTimepickerInput"], { "matTimepicker": { "alias": "matTimepicker"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, {}, never, never, false, never>;
}

interface ClockDialViewCell {
    value: number;
    displayValue: string;
    left: number;
    top: number;
    disabled: boolean;
}
declare const ALL_HOURS: number[];
declare class MatHoursClockDial implements OnInit {
    private _element;
    private _cdr;
    private _document;
    private _window;
    /** Selected hour. */
    get selectedHour(): number;
    set selectedHour(value: number);
    private _selectedHour;
    /** Whether the clock uses 12 hour format. */
    get isMeridiem(): boolean;
    set isMeridiem(value: boolean);
    private _isMeridiem;
    get availableHours(): number[];
    set availableHours(value: number[]);
    private _availableHours;
    /** Color palette. */
    color: ThemePalette;
    /** Emits selected hour. */
    selectedChange: EventEmitter<{
        hour: number;
        changeView?: boolean;
    }>;
    hours: ClockDialViewCell[];
    get disabledHand(): boolean;
    get isHour(): boolean;
    constructor(_element: ElementRef<HTMLElement>, _cdr: ChangeDetectorRef, _document: Document, _window: Window);
    ngOnInit(): void;
    /** Hand styles based on selected hour. */
    _handStyles(): any;
    /** Handles mouse and touch events on dial and document. */
    _onUserAction(event: MouseEvent | TouchEvent): void;
    _isActiveCell(hour: number): boolean;
    _trackBy(index: number, cell: ClockDialViewCell): number;
    /** Changes selected hour based on coordinates. */
    private _setHour;
    /** Return value of hour. */
    private _getHourValue;
    /** Creates list of hours. */
    private _initHours;
    /** Returns radius based on hour */
    private _getRadius;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatHoursClockDial, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatHoursClockDial, "mat-hours-clock-dial", ["matHoursClockDial"], { "selectedHour": { "alias": "selectedHour"; "required": false; }; "isMeridiem": { "alias": "isMeridiem"; "required": false; }; "availableHours": { "alias": "availableHours"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
}

declare const ALL_MINUTES: number[];
declare class MatMinutesClockDial implements OnInit {
    private _element;
    private _cdr;
    private _document;
    private _window;
    /** Selected minute. */
    get selectedMinute(): number;
    set selectedMinute(value: number);
    private _selectedMinute;
    /** Step over minutes. */
    get interval(): number;
    set interval(value: number);
    private _interval;
    get availableMinutes(): number[];
    set availableMinutes(value: number[]);
    private _availableMinutes;
    /** Color palette. */
    color: ThemePalette;
    /** Emits selected minute. */
    selectedChange: EventEmitter<number>;
    minutes: ClockDialViewCell[];
    get disabled(): boolean;
    get isMinutePoint(): boolean;
    constructor(_element: ElementRef<HTMLElement>, _cdr: ChangeDetectorRef, _document: Document, _window: Window);
    ngOnInit(): void;
    /** Hand styles based on selected minute. */
    _handStyles(): any;
    /** Handles mouse and touch events on dial and document. */
    _onUserAction(event: MouseEvent | TouchEvent): void;
    _isActiveCell(minute: number): boolean;
    _trackBy(index: number, cell: ClockDialViewCell): number;
    private _setMinute;
    /** Creates list of minutes. */
    private _initMinutes;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMinutesClockDial, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatMinutesClockDial, "mat-minutes-clock-dial", ["matMinutesClockDial"], { "selectedMinute": { "alias": "selectedMinute"; "required": false; }; "interval": { "alias": "interval"; "required": false; }; "availableMinutes": { "alias": "availableMinutes"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
}

/** Button that will close the timepicker and assign the current selection to the data model. */
declare class MatTimepickerApply {
    private _timepicker;
    constructor(_timepicker: MatTimepickerBase<MatTimepickerControl<any>, unknown>);
    _applySelection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerApply, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerApply, "[matTimepickerApply]", never, {}, {}, never, never, false, never>;
}
/** Button that will close the timepicker and discard the current selection. */
declare class MatTimepickerCancel {
    private _timepicker;
    constructor(_timepicker: MatTimepickerBase<MatTimepickerControl<any>, unknown>);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerCancel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerCancel, "[matTimepickerCancel]", never, {}, {}, never, never, false, never>;
}
/**
 * Container that can be used to project a row of action buttons
 * to the bottom of a timepicker.
 */
declare class MatTimepickerActions implements AfterViewInit, OnDestroy {
    private _timepicker;
    private _viewContainerRef;
    _template: TemplateRef<unknown>;
    private _portal;
    constructor(_timepicker: MatTimepickerBase<MatTimepickerControl<any>, unknown>, _viewContainerRef: ViewContainerRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerActions, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerActions, "mat-timepicker-actions", never, {}, {}, never, ["*"], false, never>;
}
/**
 * Default action buttons to the bottom of a timepicker.
 */
declare class MatTimepickerDefaultActions implements OnInit {
    private _timepicker;
    _intl: MatTimepickerIntl;
    constructor(elementRef: ElementRef, _timepicker: MatTimepickerBase<MatTimepickerControl<any>, unknown>, _intl: MatTimepickerIntl);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerDefaultActions, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerDefaultActions, "mat-timepicker-default-actions", never, {}, {}, never, ["*"], false, never>;
}

declare class MatTimepickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTimepickerModule, [typeof MatTimepickerToggle, typeof MatTimepickerToggleIcon, typeof MatTimepicker, typeof MatTimepickerContent, typeof MatTimepickerContentLayout, typeof MatTimepickerInput, typeof MatTimeInputs, typeof MatHourInput, typeof MatMinuteInput, typeof MatClockDials, typeof MatHoursClockDial, typeof MatMinutesClockDial, typeof MatTimePeriod, typeof MatTimepickerActions, typeof MatTimepickerDefaultActions, typeof MatTimepickerApply, typeof MatTimepickerCancel], [typeof i2.CommonModule, typeof i4$1.MatButtonModule, typeof i14.MatFormFieldModule, typeof i15.MatInputModule, typeof i14$1.MatIconModule, typeof i18.MatRippleModule, typeof i11.MatDividerModule, typeof i19.OverlayModule, typeof i20.PortalModule, typeof i21.A11yModule], [typeof i22.CdkScrollableModule, typeof MatTimepickerToggle, typeof MatTimepickerToggleIcon, typeof MatTimepicker, typeof MatTimepickerContent, typeof MatTimepickerContentLayout, typeof MatTimepickerInput, typeof MatTimeInputs, typeof MatHourInput, typeof MatMinuteInput, typeof MatClockDials, typeof MatHoursClockDial, typeof MatMinutesClockDial, typeof MatTimepickerActions, typeof MatTimepickerDefaultActions, typeof MatTimepickerApply, typeof MatTimepickerCancel]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MatTimepickerModule>;
}

declare const MAT_DEFAULT_ACITONS: InjectionToken<ComponentType<any>>;

/** Injection token that determines the scroll handling while the timepicker is open. */
declare const MAT_TIMEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
/** Timepicker scroll strategy factory. */
declare function MAT_TIMEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
/** Timepicker scroll strategy provider. */
declare const MAT_TIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
    provide: InjectionToken<() => ScrollStrategy>;
    deps: (typeof Overlay)[];
    useFactory: typeof MAT_TIMEPICKER_SCROLL_STRATEGY_FACTORY;
};

declare class CoreMatModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreMatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreMatModule, never, [typeof i1$1.MatAutocompleteModule, typeof i2$1.MatBadgeModule, typeof i3$1.MatBottomSheetModule, typeof i4$1.MatButtonModule, typeof i5$1.MatButtonToggleModule, typeof i6$1.MatCardModule, typeof i7.MatCheckboxModule, typeof i8.MatChipsModule, typeof i9.MatDatepickerModule, typeof i10.MatDialogModule, typeof i11.MatDividerModule, typeof i12.MatExpansionModule, typeof i13.MatGridListModule, typeof i14$1.MatIconModule, typeof i15.MatInputModule, typeof i16.MatListModule, typeof i17.MatMenuModule, typeof i18.MatNativeDateModule, typeof i19$1.MatPaginatorModule, typeof i20$1.MatProgressBarModule, typeof i21$1.MatProgressSpinnerModule, typeof i22$1.MatRadioModule, typeof i18.MatRippleModule, typeof i23.MatSelectModule, typeof i24.MatSidenavModule, typeof i25.MatSliderModule, typeof i26.MatSlideToggleModule, typeof i27.MatSnackBarModule, typeof i28.MatSortModule, typeof i29.MatStepperModule, typeof i30.MatTableModule, typeof i31.MatTabsModule, typeof i32.MatToolbarModule, typeof i33.MatTooltipModule, typeof i34.MatTreeModule], [typeof i1$1.MatAutocompleteModule, typeof i2$1.MatBadgeModule, typeof i3$1.MatBottomSheetModule, typeof i4$1.MatButtonModule, typeof i5$1.MatButtonToggleModule, typeof i6$1.MatCardModule, typeof i7.MatCheckboxModule, typeof i8.MatChipsModule, typeof i9.MatDatepickerModule, typeof i10.MatDialogModule, typeof i11.MatDividerModule, typeof i12.MatExpansionModule, typeof i13.MatGridListModule, typeof i14$1.MatIconModule, typeof i15.MatInputModule, typeof i16.MatListModule, typeof i17.MatMenuModule, typeof i18.MatNativeDateModule, typeof i19$1.MatPaginatorModule, typeof i20$1.MatProgressBarModule, typeof i21$1.MatProgressSpinnerModule, typeof i22$1.MatRadioModule, typeof i18.MatRippleModule, typeof i23.MatSelectModule, typeof i24.MatSidenavModule, typeof i25.MatSliderModule, typeof i26.MatSlideToggleModule, typeof i27.MatSnackBarModule, typeof i28.MatSortModule, typeof i29.MatStepperModule, typeof i30.MatTableModule, typeof i31.MatTabsModule, typeof i32.MatToolbarModule, typeof i33.MatTooltipModule, typeof i34.MatTreeModule, typeof MatTimepickerModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreMatModule>;
}

interface ISimpleComboboxItem {
    id: number | string;
    text: string;
    description?: string;
}

interface IInfoOrganization {
    id?: number;
    nameFull: string;
    nameShort: string;
    inn: string;
    kpp: string;
    ogrn?: string;
    okopf?: ISimpleComboboxItem;
    code?: string;
}
declare class InfoOrganization implements IInfoOrganization {
    id?: number;
    nameFull: string;
    nameShort: string;
    inn: string;
    kpp: string;
    ogrn?: string;
    okopf?: ISimpleComboboxItem;
    code?: string;
}

interface IInfoUser {
    id?: number;
    firstName: string;
    lastName: string;
    middleName: string;
    email: string;
    login?: string;
}
declare class InfoUser implements IInfoUser {
    id?: number;
    firstName: string;
    lastName: string;
    middleName: string;
    email: string;
    login?: string;
    static getOperatorShortName(operator: IInfoUser): string;
    static getOperatorShortNameValue(lastName: string, firstName: string, middleName?: string): string;
}

interface ISimpleAccess {
    systemObjectId: number;
    view: boolean;
    edit: boolean;
    add: boolean;
    delete: boolean;
}

interface IOrganizationComboboxItem {
    id: number;
    name: string;
    inn: string;
    kpp: string;
}

interface IPersonComboboxItem {
    id: number;
    firstName: string;
    middleName: string;
    lastName: string;
    email: string;
}

interface IUserComboboxItem {
    id: number;
    login: string;
    name: string;
}

interface ICardFrame {
    readonlyMode: boolean;
}
declare class CardFrame implements ICardFrame {
    readonlyMode: boolean;
}
interface ICardButton {
    name: string;
    text: string;
    action?: Function;
}
declare class CardButton {
    name: string;
    text: string;
    action: Function;
    constructor(name: string, text: string, func?: Function);
}
interface ICardPanel {
    name: string;
    title: string;
    buttons: ICardButton[];
}
declare class CardPanel {
    name: string;
    title: string;
    buttons: ICardButton[];
    constructor(noButton?: boolean);
    private initDefaultButtons;
}

interface IButton {
    name: string;
    text: string;
    hidden: boolean;
    action: Function;
}

interface IPanel {
    name: string;
    title: string;
    expanded?: boolean;
    hidden: boolean;
    dataObject?: any;
    editable?: IPanelEditable;
    disabled?: boolean;
    hideToggle?: boolean;
    addButtonVisible?: boolean;
    addButtonTitle?: string;
    navigationOrder?: number;
}
interface IPanelEditable {
    formIsReadonly: boolean;
    saveAction?: Function;
    cancelAction?: Function;
}

interface IDictionaryItem {
    id: number;
    name: string;
    description: string;
}
declare class DictionaryItem implements IDictionaryItem {
    id: number;
    name: string;
    description: string;
    constructor();
}

declare class Exception {
    code: string;
    template: string;
    constructor(code: string, template: string);
}

declare class MenuItem {
    recordId: string;
    text: string;
    tooltip?: string;
    blockTitleBackgroundColor?: string;
    blockTitleForegroundColor?: string;
    url: string;
    icon: string;
    name: string;
    isDirect: boolean;
    settings: MenuSetting;
    expanded: boolean;
    subMenuItems: MenuItem[];
    selected?: boolean;
    expandedInit?: boolean;
    accordion?: MatAccordion;
    constructor();
}
declare class MenuSetting {
    openInNewWindow: boolean;
    needNewBtn: boolean;
    needNotification: boolean;
    notificationCount?: number;
    canDeleteView?: boolean;
    userViewName: string;
    isShared?: boolean;
    miniDraftRemoteName: string;
    miniDraftRemoteExposedModule: string;
    miniDraftRemoteComponent: string;
}

declare class GridDataEvent {
    isNewElement: boolean;
    element: any;
    constructor(newElement: boolean, element: any);
}

interface ICertificate {
    hash: string;
    subject: string;
    issuer: string;
    validAfter: string;
    validBefore: string;
    displayValidDate: string;
    enabled: boolean;
    person?: string;
    firstName?: string;
    lastName?: string;
    middleName?: string;
    snils?: string;
    organization?: string;
    inn?: string;
    ogrn?: string;
    ogrnip?: string;
    attorneyId?: string;
    get isOrganization(): boolean;
}
declare class Certificate implements ICertificate {
    certificateActive: boolean;
    hash: string;
    subject: string;
    issuer: string;
    validAfter: string;
    validBefore: string;
    displayValidDate: string;
    enabled: boolean;
    person?: string;
    firstName?: string;
    lastName?: string;
    middleName?: string;
    snils?: string;
    organization?: string;
    inn?: string;
    ogrn?: string;
    ogrnip?: string;
    attorneyId?: string;
    constructor(certificate: any);
    get isOrganization(): boolean;
    private _parsePerson;
    private _parseSnils;
    private _parseInn;
    private _parseOgrn;
    private _parseOgrnip;
    private _parseOrganizatioin;
}

interface IFileSignProcessItem {
    fileId: string;
    signature: any;
}
interface IFileDataForSign {
    fileId: string;
    isHashString: boolean;
    stringForSign: string;
}
declare class FileDataForSign implements IFileDataForSign {
    fileId: string;
    isHashString: boolean;
    stringForSign: string;
}

interface ICryptoSignature {
    data: any;
    isDetached: boolean;
    signature: any;
}
declare class CryptoSignature implements ICryptoSignature {
    data: any;
    isDetached: boolean;
    isHashString: boolean;
    signature: any;
    constructor(data: any, signature: any, isDetached: boolean, isHashString?: boolean);
}

interface ISignatureInfo {
    fileId: string;
    fileName: string;
    fileUrl: string;
    fileSize: string;
    signId: string;
    signatureStatus: string;
    authority: number;
    signUrl?: string;
    organization?: string;
    userName?: string;
    serialNumber?: string;
    certificateUrl?: string;
    authorityFileId?: string;
    authorityFileUrl?: string;
    validFrom?: Date;
    validTo?: Date;
    signingTime?: Date;
    signerIp?: string;
    signerCountryCode?: string;
    needUploadAuthFile?: boolean;
    attorneyId?: string;
    attorneyNumber?: string;
    attorneyDate?: Date;
    attorneyPrintFormId?: string;
    attorneyPrintFormUrl?: string;
    hasUnstructuredPowers?: boolean;
}
declare enum AuthorityEnum {
    Ceo = 1,
    NotCeo = 2,
    Ip = 3
}

interface IPair {
    key: string;
    value: any;
}
declare class Pair implements IPair {
    key: string;
    value: any;
    constructor(key: string, value: any);
}
declare class TPair<T> implements IPair {
    key: string;
    value: T;
    constructor(key: string, value: T);
}

interface IFilterItem {
    field: string;
    condition: string;
    value: any;
}
interface ISortItem {
    field: string;
    direction: any;
}
declare class PaginatorSource {
    pageIndex: number;
    pageSize: number;
    total: number;
    constructor();
    initLocalization(paginator: MatPaginator): void;
    paginate(data: any[]): any;
    private dutchRangeLabel;
}
interface IQueryDataSertviceAdditionalParams {
    entityId?: number | string;
    organizationId?: number;
    sourseSelector?: string;
    additionParams?: IPair[];
    conditionFunc?: Function;
}
interface IQueryDataSertvice<T> {
    getDataSourceItems: (query: string, params?: IQueryDataSertviceAdditionalParams) => Observable<T[]>;
}
declare class GridConfiguration<T> implements IGridConfiguration<T> {
    paginator: PaginatorSource;
    dataService: IQueryDataSertvice<T>;
    constructor(service?: IQueryDataSertvice<T>);
}

interface IGridConfiguration<T> {
    paginator: PaginatorSource;
    sort?: ISortItem;
    filters?: IFilterItem[];
    dataService: IQueryDataSertvice<T>;
}

declare class ClientSideDataSource<T> implements DataSource<T> {
    private _schema;
    private _subject;
    private _loadingSubject;
    loading$: Observable<boolean>;
    constructor(_schema: IGridConfiguration<T>);
    connect(): Observable<T[]>;
    disconnect(): void;
    initLocalization(paginator: MatPaginator): void;
    loadDataSourceItems(items: T[]): void;
}

declare enum FieldTypeEnum {
    String = 1,
    Int = 2,
    Bool = 3,
    Decimal = 4,
    DateTime = 5
}

declare class ExportedData {
    name: string;
    headers: IGridColumn[];
    rows: any[];
}
interface IGridColumn {
    key: string;
    name: string;
    dataType: FieldTypeEnum;
    accociatedKey?: string;
}
/**
 * @deprecated The method should not be used
 */
declare class GridColumn implements IGridColumn {
    key: string;
    name: string;
    dataType: FieldTypeEnum;
    accociatedKey?: string;
    constructor(key: string, name: string, dataType?: FieldTypeEnum);
}

declare class Startup {
    get startupData(): IPair[];
    webSubfolder(): string;
    apiRoot(url: string, api?: string, version?: string): string;
    getByKey(key: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<Startup, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Startup>;
}

declare class StorageCheck {
    static storageAvailable(type: string): boolean;
}
declare abstract class AbstractStorage implements Storage {
    readonly length: number;
    abstract clear(): void;
    abstract getItem(key: string): string | null;
    abstract getTyped<T>(key: string): T | null;
    abstract key(index: number): string | null;
    abstract removeItem(key: string): void;
    abstract setItem(key: string, value: string): void;
}

declare class BrowserLocalStorage implements LocalStorage {
    /**
     * Storage
     */
    private readonly storage;
    constructor();
    get length(): number;
    clear(): void;
    getItem(key: string): string | any;
    getTyped<T>(key: string): T;
    key(index: number): string | null;
    removeItem(key: string): void;
    setItem(key: string, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserLocalStorage, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserLocalStorage>;
}
declare abstract class LocalStorage extends AbstractStorage {
}

interface IMethodOptions {
    url: string;
    data?: Object;
    contentType?: string;
    httpOptions?: Object;
    callback?: Function;
    progress?: Function;
}
declare class MethodOptions implements IMethodOptions {
    url: string;
    data?: Object;
    contentType?: string;
    callback?: Function;
    constructor(contentType?: string);
}
declare class AjaxService {
    private _http;
    private _sessionStorage;
    private _startUp;
    constructor(_http: HttpClient, _sessionStorage: BrowserLocalStorage, _startUp: Startup);
    get(options: IMethodOptions): Observable<any>;
    post(options: IMethodOptions): Observable<any>;
    delete(options: IMethodOptions): Observable<any>;
    put(options: IMethodOptions): Observable<any>;
    download(data: IMethodOptions): void;
    run(options: IMethodOptions): void;
    check(url: string, successCallback: Function, progressCallback: Function): void;
    errorHandler(error: any): Observable<never>;
    private makeHttpOption;
    private _createAndDownloadBlobFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<AjaxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AjaxService>;
}

declare class DataExportService {
    _ajaxM: AjaxService;
    _startUp: Startup;
    constructor(_ajaxM: AjaxService, _startUp: Startup);
    exportData(data: ExportedData): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataExportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataExportService>;
}

declare const ALTERNATIVE_FILTER_CONDITIONS: {
    cond: string;
    alt: string;
    state: string;
}[];
declare class ServerSideDataSource<T> implements DataSource<T> {
    private _schema;
    private _dataExportService;
    private _defaultFilters?;
    private _lastQuery;
    private _subject;
    private _loadingSubject;
    private _signalsSubject;
    private _additionalParams?;
    loading$: Observable<boolean>;
    dataItems: T[];
    signals$: Observable<any[]>;
    get signals(): any[];
    private set signals(value);
    constructor(_schema: IGridConfiguration<T>, _dataExportService: DataExportService, _defaultFilters?: IFilterItem[]);
    connect(): Observable<T[]>;
    disconnect(): void;
    update(items: T[]): void;
    initLocalization(paginator: MatPaginator): void;
    useFilter(filter: IFilterItem, action: Function, getAdditionalParams?: Function, callback?: Function): void;
    useFilters(filters: IFilterItem[], action: Function, getAdditionalParams?: Function, callback?: Function): void;
    registrateFilterItem(filter: IFilterItem, action: Function, getAdditionalParams?: Function, callback?: Function): void;
    registrateFilter(filterInput: ElementRef, action: Function, eventName?: string, getAdditionalParams?: Function, callback?: Function): void;
    private FilterInternalLogic;
    forceLoading(): void;
    setPageIndex(pageIndex: number): void;
    loadDataSourceItems(params?: IQueryDataSertviceAdditionalParams, callback?: Function): void;
    buildQuery(pageIndex?: number, pageSize?: number): string;
    exportExcel(columns: any, exportAdditionalParamsFunc?: Function, onCompleted?: () => void, onError?: (error: any) => void): void;
}

interface IResponse {
    isSuccess: boolean;
    type?: number | string;
    message: string;
}
interface IEntityResponse {
    isSuccess: boolean;
    type?: number | string;
    message: string;
    entity: any;
}

declare class CommonVisualSetting {
    isRegistrationEnabled: boolean;
    isPersonsWorkEnabled: boolean;
    isSignatureWorkEnabled: boolean;
    isSystemReglamentSigned: boolean;
    isAgentOrganization?: boolean;
    userVerificationMode: UserVerificationMode;
    isTwoFactorEnabled: boolean;
    isPhoneAuthorizationAllowed: boolean;
    phoneVerificationServiceWorkingMode: PhoneVerificationServiceWorkingMode;
    reCapchaEnabled: boolean;
    reCapchaFaildCount: number;
}
declare class PlatformVisualSetting {
    code: string;
    name: string;
    nameEng: string;
    isShowPhone: string;
    phoneFirst: string;
    phoneSecond: string;
    email: string;
    linkWhatsApp?: string;
    linkTelegram?: string;
    linkTelegramBot?: string;
    linkTermsOfUse: string;
    linkPersonalInformation: string;
}
declare class BrokerVisualSetting {
    isRasSigned: boolean;
}
declare class VirtualAccount {
    account: string;
    bloked: number;
    free: number;
}
declare class PersonVerification {
    phone?: string;
    email?: string;
    telegram?: string;
    isPhoneVerificated: boolean;
    isEmailVerificated: boolean;
    isTelegramVerified: boolean;
}
declare class RequestVisualSettings {
    showFundingGuide?: boolean;
}
declare class VisualSettings {
    common: CommonVisualSetting;
    platform: PlatformVisualSetting;
    brokers?: BrokerVisualSetting;
    virtualAccount: VirtualAccount;
    verification: PersonVerification;
    request: RequestVisualSettings;
}
declare enum UserVerificationMode {
    None = "None",
    OnlyEmail = "OnlyEmail",
    OnlyPhone = "OnlyPhone",
    All = "All",
    OnlyOne = "OnlyOne"
}
declare enum PhoneVerificationServiceWorkingMode {
    Default = "Default",
    Voice = "Voice",
    Mix = "Mix"
}

interface IEditDictionaryItem {
    id: number;
    key: string;
    name: string;
    description: string;
    organization: ISimpleComboboxItem;
    isSystem: boolean;
    useSetedKey?: boolean;
    useForAll?: boolean;
}
declare class EditDictionaryItem implements IEditDictionaryItem {
    id: number;
    key: string;
    name: string;
    description: string;
    organization: ISimpleComboboxItem;
    isSystem: boolean;
}

declare enum FileTypeEnum {
    None = 1,
    Passport = 2,
    InternationalPassport = 3,
    Snils = 4,
    Ogrn = 5,
    CompanyRegulations = 6,
    DecisionOnAppointment = 7,
    Egrul = 8,
    SystemReglament = 9,
    ProcessingOfPersonalDataReglament = 10,
    Accounting = 11,
    AccountingXml = 12,// todo: проверить что где то используется, если нет то убрать
    OrganizationProfile = 13,
    OrganizationProfileXml = 14,// todo: проверить что где то используется, если нет то убрат
    OrganizationInn = 15,
    PersonInn = 16,
    License = 17,
    MigrationCard = 18,
    Visa = 19,
    TemporaryResidencePermits = 20,
    ResidencePermits = 21,
    DocGeneratedMetadata = 23,// todo: проверить что где то используется, если нет то убрат
    DocGeneratedPatern = 24,
    PanelPrintForm = 25,
    SupplyContract = 26,
    SupplyContractConfirmation = 27,
    OfficeConfirmation = 28,
    AccountingFNS = 29,
    PowerOfAttorney = 30,
    ReviewsOfFinancialOrganizations = 31,
    ReviewsOfContractors = 32,
    LetterOfNoInterest = 33,
    DealApprovalDocuments = 34,
    FactoringOffer = 36,
    SystemFinanceReglament = 37,
    DealDecision = 39,
    ScoringVerdict = 40,
    ProcessingFinancialDataReglament = 41,
    PodFtProfile = 42,
    PaymentOrder = 43,
    ChatAttachment = 44,
    ProviderOrganizationProfile = 45,
    CashOutStatement = 46,
    Ras = 47,
    RasAttachment = 48,
    MachineReadableAttorney = 49,
    MachineReadableAttorneyXml = 50,
    BrokerProfile = 51,
    PurchasingFactoringOffer = 52,
    SupplementaryAgreement = 53,
    PaymentOrderAnalyticAccount = 54,
    Notification = 55,
    AssetsFreezeReport = 56,
    FundingInstruction = 57,
    MraReport = 58,
    MonitoringFinancialReport = 59
}
declare const FilesLabel: Map<number, string>;
interface IFileTypeItem extends IEditDictionaryItem {
    isVersioned: boolean;
    isMultiVersioned: boolean;
    versionLevel: ISimpleComboboxItem;
}
declare class FileTypeItem extends EditDictionaryItem implements IFileTypeItem {
    isVersioned: boolean;
    isMultiVersioned: boolean;
    versionLevel: ISimpleComboboxItem;
}

declare class UploadedFileAttribute {
    attributeTypeId: number;
    value: string;
}
declare class UploadedFile {
    fileId: string;
    fileName: string;
    fileUrl: string;
    canDelete: boolean;
    hasSingatures: boolean;
    isArchived: boolean;
    attributes: UploadedFileAttribute[];
}
declare class UploaderConfig {
    typeId: number;
    typeName: string;
    useInformer?: boolean;
    miniButton?: boolean;
    informerIcon?: string;
    informerText?: string;
    useDragAndDrop?: boolean;
    multiple: boolean;
    isRequired?: boolean;
    isNeedSign?: boolean;
    isDgsFile?: boolean;
    dgsBtnName: string;
    isAchiveFile?: boolean;
    isAchiveFileNew?: boolean;
    isReadOnly?: boolean;
    isExternalLoad: boolean;
    accept?: string;
    folderId?: string;
    files?: UploadedFile[];
    isTemp?: boolean;
    achiveFileMultiId?: number;
    url: string;
    hideList: boolean;
    hideSelectBtn: boolean;
    hiddenLink?: boolean;
    callback: Function;
    hideViewBtn?: boolean;
    hideDownloadBtn?: boolean;
    hideAttributeBtn?: boolean;
    signConfig?: UploaderConfig;
    constructor(typeId?: number, url?: string);
}

declare enum RolesEnum {
    System = 1,
    Broker = 2,
    Provider = 3,
    Consumer = 4
}
declare enum ParticipationEnum {
    Administrator = 100,
    Operator = 101,
    PhysicalPerson = 102,
    IntegrationBusUser = 103
}

declare enum MiniDraftModeEnum {
    Classic = 1,
    DraftInWindow = 2
}

declare class CoreAbstractComponent {
    hostID: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAbstractComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAbstractComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare abstract class CoreBaseDestroyComponent extends CoreAbstractComponent implements OnDestroy {
    protected _destroy$: ReplaySubject<boolean>;
    protected takeUntilDestroyed<T>(): MonoTypeOperatorFunction<T>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreBaseDestroyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreBaseDestroyComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreSelectSearchComponent extends CoreBaseDestroyComponent implements OnInit, AfterViewInit, ControlValueAccessor {
    matSelect: MatSelect;
    private changeDetectorRef;
    placeholderLabel: string;
    noEntriesFoundLabel: string;
    searchSelectInput: ElementRef;
    /** Reference to the MatSelect options */
    _options: QueryList<MatOption>;
    /** Previously selected values when using <mat-select [multiple]="true">*/
    private previousSelectedValues;
    /** Whether the backdrop class has been set */
    private overlayClassSet;
    /** Event that emits when the current value changes */
    private change;
    private _value;
    get value(): string;
    onChange: Function;
    onTouched: Function;
    constructor(matSelect: MatSelect, changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Handles the key down event with MatSelect.
     * Allows e.g. selecting with enter key, navigation with arrow keys, etc.
     */
    _handleKeydown(event: KeyboardEvent): void;
    writeValue(value: string): void;
    onInputChange(value: string): void;
    onPaste(event: ClipboardEvent): void;
    onBlur(value: string): void;
    registerOnChange(fn: Function): void;
    registerOnTouched(fn: Function): void;
    /**
     * Focuses the search input field
     */
    _focus(): void;
    /**
     * Resets the current search value
     */
    _reset(focus?: boolean): void;
    /**
     * Sets the overlay class  to correct offsetY
     * so that the selected option is at the position of the select box when opening
     */
    private setOverlayClass;
    /**
     * Initializes handling <mat-select [multiple]="true">
     * Note: to improve this code, mat-select should be extended to allow disabling resetting the selection while filtering.
     */
    private initMultipleHandling;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreSelectSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreSelectSearchComponent, "core-select-search", never, { "placeholderLabel": { "alias": "placeholderLabel"; "required": false; }; "noEntriesFoundLabel": { "alias": "noEntriesFoundLabel"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ExternalRedirectComponent extends CoreAbstractComponent implements OnInit {
    private _startUpM;
    private _route;
    constructor(_startUpM: Startup, _route: ActivatedRoute);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalRedirectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalRedirectComponent, "core-redirect", never, {}, {}, never, never, false, never>;
}

interface FiltrationItem {
    key: string;
    value: any;
    /**
     * Необязательный флаг: если установлен в true и value пустой (Utility.isEmpty),
     * то загрузка данных в связанных контролах (например, CoreFieldTypeComboboxComponent)
     * не выполняется.
     */
    skipIfEmpty?: boolean;
}
interface Filtration {
    text: string;
    expression: FiltrationItem[];
}

declare enum BooleanMode {
    Option = "Option",
    Checkbox = "Checkbox",
    Slide = "Slide",
    YesNo = "YesNo"
}
declare enum RequisitsMode {
    All = "All",
    Fiz = "Fiz",
    Jur = "Jur"
}
interface IFieldSetting {
    isRequired?: boolean;
    isReadonly?: boolean;
    useInformer?: boolean;
    informerIcon?: string;
    informerText?: string;
    leftHint?: string;
    rightHintHide?: boolean;
    useBorder?: boolean;
    defaultText?: string;
    maxLength?: number;
    rowCount?: number;
    useMask?: boolean;
    maskExpression?: string;
    decimals?: number;
    minN?: number;
    maxN?: number;
    isMoney?: boolean;
    moneyText?: string;
    isPercentage?: boolean;
    percentageText?: string;
    mode?: BooleanMode;
    requisitesMode?: RequisitsMode;
    positiveText?: string;
    positiveinformerText?: string;
    negativeText?: string;
    negativeinformerText?: string;
    minD?: Date;
    maxD?: Date;
    minCount?: number;
    maxCount?: number;
    sourceCode?: string;
    recordCount?: number;
    selectFirst?: boolean;
    module?: string;
    masterD?: string;
    expressionD?: FiltrationItem[];
    emptyText?: string;
    hideEmpty?: boolean;
    hideSearch?: boolean;
    tempData?: IPair[];
    needVerificate?: boolean;
    requestStatusId?: number;
}
declare class FieldSetting implements IFieldSetting {
    isRequired?: boolean;
    isReadonly?: boolean;
    useInformer?: boolean;
    informerIcon?: string;
    informerText?: string;
    leftHint?: string;
    rightHintHide?: boolean;
    useBorder?: boolean;
    defaultText?: string;
    maxLength?: number;
    rowCount?: number;
    useMask?: boolean;
    maskExpression?: string;
    decimals?: number;
    minN?: number;
    maxN?: number;
    isMoney?: boolean;
    moneyText?: string;
    isPercentage?: boolean;
    percentageText?: string;
    mode?: BooleanMode;
    requisitesMode?: RequisitsMode;
    positiveText?: string;
    positiveinformerText?: string;
    negativeText?: string;
    negativeinformerText?: string;
    minD?: Date;
    maxD?: Date;
    minCount?: number;
    maxCount?: number;
    sourceCode?: string;
    recordCount?: number;
    selectFirst?: boolean;
    module?: string;
    masterD?: string;
    expressionD?: FiltrationItem[];
    emptyText?: string;
    hideEmpty?: boolean;
    hideSearch?: boolean;
    tempData?: IPair[];
    needVerificate?: boolean;
    constructor();
}

declare class CoreAbstractAccessorComponent extends CoreBaseDestroyComponent implements ControlValueAccessor, OnDestroy {
    hideRequiredMarker: boolean;
    disabled: boolean;
    placeholder: string;
    labelClass: string;
    cmpClass: string;
    fieldName?: string;
    settings?: IFieldSetting;
    section?: string;
    valueChange: EventEmitter<any>;
    unfocus: EventEmitter<any>;
    validationDone: EventEmitter<IPair[]>;
    private _value;
    get value(): any;
    set value(v: any);
    constructor();
    onChange: Function;
    onTouched: Function;
    onUnfocused(model: any): void;
    formatValue(model: any): any;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    onValueChange(model: any): void;
    setDefault(): void;
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAbstractAccessorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAbstractAccessorComponent, "ng-component", never, { "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "labelClass": { "alias": "labelClass"; "required": false; }; "cmpClass": { "alias": "cmpClass"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "section": { "alias": "section"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "unfocus": "unfocus"; "validationDone": "validationDone"; }, never, never, false, never>;
}

interface IAnswer {
    value: boolean;
    title: string;
    informerText: string;
}
declare class CoreFieldTypeBoolComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    ansvers: IAnswer[];
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): boolean;
    setDefault(): void;
    onBoolValueChange(model: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeBoolComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeBoolComponent, "core-field-bool", never, {}, {}, never, never, false, never>;
}

declare class CoreClientGrid<T> extends CoreBaseDestroyComponent implements AfterViewInit, OnInit {
    _displayedColumns: string[];
    _gridConfig: IGridConfiguration<T>;
    _dataSource: ClientSideDataSource<T>;
    _paginator: MatPaginator;
    _sort: MatSort;
    dataSource(): T[];
    sortingLogic(sort: Sort): void;
    get hiddenPaginator(): string;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    sortData(sort: Sort): void;
    compare(a: number | string, b: number | string, isAsc: boolean): any;
    refresh(items: T[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreClientGrid<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreClientGrid<any>, "ng-component", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated Этот класс устарел и будет удален в будущих версиях
 */
declare class CoreGrid<T> extends CoreBaseDestroyComponent implements AfterViewInit, OnInit, AfterContentChecked {
    private _am;
    _dataExportService: DataExportService;
    _displayedColumns: string[];
    _gridConfig: IGridConfiguration<T>;
    _dataSource: ServerSideDataSource<T>;
    _defaultFilters: IFilterItem[];
    _exportedColumns: IGridColumn[];
    selected: string[];
    isAllSelected: boolean;
    showOnlySelected: boolean;
    selectItem: EventEmitter<string[]>;
    _paginator: MatPaginator;
    _sort: MatSort;
    get anyRecords(): boolean;
    loadGridConfiguration(): IGridConfiguration<T>;
    loadAdditionalParams(): IQueryDataSertviceAdditionalParams;
    loadToolbarConfiguration(): void;
    afterLoadingCallback(): void;
    constructor(injector: Injector);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngAfterContentChecked(): void;
    refreshClick(): void;
    exportExcel(): void;
    check(action: string, obj?: any): boolean;
    setSystemObj(sysObj: string): void;
    initGridMainConfiguration(): void;
    initSortConfiguration(that: any): void;
    isSelectedRow(row: any): boolean;
    setIsAllSelected(): void;
    selectAll(event: any): void;
    canSelect(row: any): boolean;
    onSelectedChange(val: boolean, row: any): void;
    onRowClick(row: any): void;
    private _selectRow;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGrid<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGrid<any>, "ng-component", never, {}, { "selectItem": "selectItem"; }, never, never, false, never>;
}

declare class PageService {
    private _startUp;
    private _title;
    private _ajaxM;
    private _sessionStorage;
    haveNewChatMessage: boolean;
    constructor(_startUp: Startup, _title: Title, _ajaxM: AjaxService, _sessionStorage: BrowserLocalStorage);
    getItems(): Observable<any>;
    getVisualSetting(): Observable<any>;
    getTitle(): string;
    setTitle(title: string): void;
    setHaveNewChatMessage(mark: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PageService>;
}

declare class CoreTitlePage extends CoreBaseDestroyComponent implements OnInit {
    _title: string;
    _pageM: PageService;
    constructor(injector: Injector);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreTitlePage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreTitlePage, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class VisualSettingManager {
    injector: Injector;
    private _pageM;
    private _startupM;
    private _settings;
    get Setting(): VisualSettings;
    get host(): string;
    get isEmailMustVerify(): boolean;
    get isPhoneMustVerify(): boolean;
    constructor(injector: Injector);
    init(callback?: Function): void;
    getVerificationType(verificationChannel: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisualSettingManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VisualSettingManager>;
}

declare class DiagInfo {
    date: Date;
    version: string;
    host: string;
    ip: string;
    constructor();
}

declare class DiagService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getInfo(): DiagInfo;
    getIp(): Observable<DiagInfo>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DiagService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DiagService>;
}

declare class CoreBasePage extends CoreBaseDestroyComponent implements OnInit {
    diag: DiagInfo;
    VM: VisualSettingManager;
    _diagM: DiagService;
    constructor(injector: Injector);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreBasePage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreBasePage, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class AccessManager {
    private pageM;
    private _systemObj;
    private _accesses;
    constructor(pageM: PageService);
    init(callback?: Function): void;
    check(action: string, obj?: any): boolean;
    setSystemObj(sysObj: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccessManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccessManager>;
}

declare class CoreSimplePage extends CoreBasePage implements OnInit {
    AM: AccessManager;
    manualInitAM: boolean;
    constructor(injector: Injector);
    ngOnInit(): void;
    check(action: string, obj?: any): boolean;
    setSystemObj(sysObj: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreSimplePage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreSimplePage, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class LoginModel {
    login: string;
    password?: string;
    signature?: string;
    type?: string;
    code?: string;
    code_challenge?: string;
}

declare enum NotificationInfoType {
    Success = "success",
    Warning = "warning",
    Info = "info",
    Error = "error"
}

declare const CORE_NOTIFICATION_DATA_TOKEN: InjectionToken<ICoreNotificationData>;
/** конфигурация по умолчанию контейнера сообщения */
declare const CoreNotificationBaseOverlayConfig: OverlayConfig;
/** отображаемая информация */
interface ICoreNotificationMessage {
    subject?: string;
    text: string;
    useHtml?: boolean;
}
/** информация о сообщении, которая передается в динамически-создаваемый компонент сообщения */
interface ICoreNotificationData {
    message: ICoreNotificationMessage;
    type: NotificationInfoType;
    overlayRef?: OverlayRef;
}
declare const CoreNotificationUIConfig: Record<NotificationInfoType.Error | NotificationInfoType.Info | NotificationInfoType.Success | NotificationInfoType.Warning, string>;

declare class TopicRequest {
    topic: string;
    data: any;
    constructor(topic: string, data: any);
}
declare class TopicSubject {
    topic: string;
    data: Subject<any>;
    constructor(topic: string);
}
declare abstract class DefaultQueueService {
    protected _subjects: TopicSubject[];
    abstract getServiceId(): string;
    subscribeForTopic(topic: string): Observable<any>;
    notify(request: TopicRequest, delayMs?: number): void;
    clean(topic: string): void;
    get(topic: string): Observable<any>;
}

declare class CoreNotificationQueueService extends DefaultQueueService {
    static Topics: {
        INIT: string;
        CLOSE: string;
    };
    constructor();
    getServiceId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreNotificationQueueService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreNotificationQueueService>;
}

declare class СoreNotificationComponent extends CoreAbstractComponent implements OnInit {
    readonly data: ICoreNotificationData;
    private _queueService;
    settings: IToastSettings;
    timerIsBlocked: boolean;
    timer: any;
    constructor(data: ICoreNotificationData, _queueService: CoreNotificationQueueService);
    ngOnInit(): void;
    timerBlock(block: boolean): void;
    startCloseTimer(): void;
    onCloseClick(): void;
    getSubject(): string;
    onTransitionEnd($event: TransitionEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<СoreNotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<СoreNotificationComponent, "core-notification", never, {}, {}, never, never, false, never>;
}
interface IToastSettings {
    visible?: boolean;
    closing?: boolean;
}

declare class CoreNotificationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreNotificationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreNotificationModule, [typeof СoreNotificationComponent], [typeof CoreBaseModule, typeof CoreMatModule], [typeof СoreNotificationComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreNotificationModule>;
}

declare class CoreNotification {
    static success(message: string, useHtml?: boolean): void;
    static warning(message: string, useHtml?: boolean): void;
    static info(message: string, useHtml?: boolean): void;
    static error(message: string, useHtml?: boolean): void;
    private static showNotification;
}

declare class CoreNotificationService {
    private _overlay;
    private _parentInjector;
    private _queueService;
    private _appRef;
    /** Один контейнер-оверлей для всех уведомлений (стек в колонку) */
    private _containerOverlayRef?;
    private _containerElement?;
    /**
     * Сопоставление "токена" из очереди (передаётся как overlayRef в данных компонента)
     * и реально созданного компонента.
     */
    private _notificationEntries;
    private _overlayConfig;
    constructor(_overlay: Overlay, _parentInjector: Injector, _queueService: CoreNotificationQueueService, _appRef: ApplicationRef);
    private _ensureContainer;
    private _show;
    private _close;
    private _getMessage;
    /** закрыть все отображенные сообщения */
    closeAll(): void;
    /** отобразить информационное сообщение */
    showInfo(message: ICoreNotificationMessage | string): void;
    /** отобразить сообщение об ошибке */
    showError(message: ICoreNotificationMessage | string): void;
    /**отобразить массив ошибок*/
    showErrors(errors: string[]): void;
    /**отобразить уведомление*/
    showNotification(text: string, typeNotification: NotificationInfoType, subject?: string, useHtml?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreNotificationService>;
}

declare class NotificationDetailService {
    private _notificationSrv;
    VM: VisualSettingManager;
    constructor(injector: Injector, _notificationSrv: CoreNotificationService);
    stopNewRequestAction(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDetailService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationDetailService>;
}

declare class AuthorizationService {
    private _dialog;
    private _startUp;
    private _router;
    private _sessionStorage;
    private _context;
    private _ajaxM;
    private _notificationSrv;
    failExecutionCount: number;
    constructor(_dialog: MatDialog, _startUp: Startup, _router: Router, _sessionStorage: BrowserLocalStorage, _context: ContextService, _ajaxM: AjaxService, _notificationSrv: CoreNotificationService);
    login(goto: string, user: LoginModel, registerFunc?: Function, errorCallback?: Function): void;
    twoFactorLogin(goto: string, user: LoginModel, errorCallback?: Function): void;
    mobileLogin(goto: string, user: LoginModel, codeChallenge: string): void;
    loginShadow(user: LoginModel, callback: Function): void;
    upSession(tokenResult: any, grantType: string, callback: Function): void;
    private loginInternal;
    private _handleErrors;
    private ask2Fa;
    logout(): void;
    getToken(): string;
    checkSession(token?: string, object?: string): Observable<any>;
    changeSeessionOrgLink(token: string, linkId: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationService>;
}

declare class LogService {
    private _isDebug;
    constructor();
    log(message: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
}

interface IOrganizationLink {
    linkId: number;
    organizationId: number;
    type: string;
    detail: IOrganizationLinkItem;
}
interface IOrganizationLinkItem {
    organizationName: string;
    organizationInn: string;
    organizationKpp: string;
    participationId: number;
    participation: string;
    departmentId: number;
    department: string;
    okopfCode: string;
    globalRoleId: number;
}
interface IOrganizationContext {
    currentLinkId: number;
    currentLink: IOrganizationLink;
    linkItems: IOrganizationLink[];
}
declare class UserSessionData {
    userId: number;
    personId: number;
    login: string;
    avatarLink: string;
    avatarColor: string;
    name: string;
    organizations: IOrganizationContext;
}
interface IChangedOrganizationContext {
    token: string;
    link: IOrganizationContext;
}

declare class ContextService {
    private _storage;
    private _logService;
    private _session;
    get session(): UserSessionData;
    constructor(_storage: BrowserLocalStorage, _logService: LogService);
    private _init;
    isSystem(): boolean;
    /**
     * @deprecated Используйте isSystem() вместо этого
    */
    isSystemRole(): boolean;
    clearSession(): void;
    updateSessionPart(field: string, value: any): void;
    chageOrganization(entity: IChangedOrganizationContext): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContextService>;
}

declare class BrowserSessionStorage implements SessionStorage {
    /**
     * Storage
     */
    private readonly storage;
    constructor();
    get length(): number;
    clear(): void;
    getItem(key: string): string | any;
    key(index: number): string | null;
    removeItem(key: string): void;
    setItem(key: string, value: any): void;
    getTyped<T>(key: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserSessionStorage, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserSessionStorage>;
}
declare abstract class SessionStorage extends AbstractStorage {
}

declare class AccessGuard {
    private _router;
    private _authService;
    private _logM;
    private _context;
    private _sessionStorage;
    constructor(_router: Router, _authService: AuthorizationService, _logM: LogService, _context: ContextService, _sessionStorage: BrowserSessionStorage);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccessGuard>;
}

declare class UnauthorizedInterceptor implements HttpInterceptor {
    private _router;
    private _injector;
    constructor(_router: Router, _injector: Injector);
    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    private handleAuthError;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnauthorizedInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnauthorizedInterceptor>;
}

declare const DEFAULT_COUNTER_ID_AOT: InjectionToken<string | number>;
declare const DEFAULT_COUNTER_ID: InjectionToken<string | number>;
declare const YANDEX_COUNTERS_CONFIGS_AOT: InjectionToken<YandexCounterConfig[]>;
declare const YANDEX_COUNTERS_CONFIGS: InjectionToken<YandexCounterConfig[]>;
interface CounterConfig {
    id?: string | number;
    params?: any;
    clickmap?: boolean;
    trackLinks?: boolean;
    accurateTrackBounce?: boolean;
    webvisor?: boolean;
    trackHash?: boolean;
    ut?: string;
    ecommerce?: string;
    triggerEvent?: boolean;
    alternative?: boolean;
}
declare class YandexCounterConfig implements CounterConfig {
    id?: string | number;
    params: any;
    clickmap: boolean;
    trackLinks: boolean;
    accurateTrackBounce: boolean;
    webvisor: boolean;
    trackHash: boolean;
    ut: string;
    ecommerce?: string;
    triggerEvent?: boolean;
    alternative?: boolean;
}

declare function defaultCounterIdFactory(counterConfigs: CounterConfig | CounterConfig[], defaultCounter?: number | string): string | number;
declare function defineDefaultId(counterConfigs: CounterConfig | CounterConfig[], defaultCounter?: number | string): string | number;
declare function countersFactory(configs: CounterConfig | CounterConfig[]): (YandexCounterConfig & CounterConfig)[];
declare function createConfigs(configs: CounterConfig | CounterConfig[]): (YandexCounterConfig & CounterConfig)[];
declare function appInitializerFactory(counterConfigs: YandexCounterConfig[], platformId: any): string | (() => string);
declare function insertMetrika(counterConfigs: YandexCounterConfig[]): string;
declare function createCounter(config: YandexCounterConfig): void;
declare function getCounterNameById(id: string | number): string;

declare class MetrikaModule {
    static forRoot(configs: CounterConfig | CounterConfig[], defaultCounterId?: number | string): ModuleWithProviders<MetrikaModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MetrikaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MetrikaModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MetrikaModule>;
}

interface CallbackOptions {
    callback?: () => any;
    ctx?: any;
}
interface CommonOptions extends CallbackOptions {
    params?: any;
    title?: any;
}
interface HitOptions extends CommonOptions {
    referer?: string;
}
declare class Metrika {
    private defaultCounterId;
    private counterConfigs;
    private positionToId;
    static getCounterNameById(id: string | number): string;
    static getCounterById(id: any): any;
    constructor(injector: Injector);
    addFileExtension(extensions: string | string[], counterPosition?: number): Promise<void>;
    extLink(url: string, options?: CommonOptions, counterPosition?: number): Promise<any>;
    file(url: string, options?: HitOptions, counterPosition?: number): Promise<any>;
    getClientID(counterPosition?: number): string;
    setUserID(userId: string, counterPosition?: number): Promise<any>;
    userParams(params: any, counterPosition?: number): Promise<any>;
    params(params: any, counterPosition?: number): Promise<any>;
    replacePhones(counterPosition?: number): Promise<any>;
    notBounce(options?: CallbackOptions, counterPosition?: number): Promise<any>;
    fireEvent(type: string, options?: CommonOptions, counterPosition?: number): Promise<any>;
    hit(url: string, options?: HitOptions, counterPosition?: number): Promise<any>;
    private getCallbackPromise;
    private counterIsLoaded;
    private getCounterByPosition;
    private getCounterIdByPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<Metrika, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Metrika>;
}

interface IFederationEntity {
    remoteName?: string;
    remoteExposedModule?: string;
    remoteComponent: string;
}
declare class FederationEntity implements IFederationEntity {
    remoteName?: string;
    remoteExposedModule?: string;
    remoteComponent: string;
}

declare class FederationLoader {
    private static _moduleCache;
    static load(entity: IFederationEntity): Promise<any>;
}

interface Actions {
    isView: boolean;
    isAdd: boolean;
    isEdit: boolean;
    isDelete: boolean;
}
interface Access {
    systemObjId: number;
    systemObj: string;
    name: string;
    actions: Actions;
    children: Access[];
}

declare class ArrayExtension {
    static isEquals(first: any, second: any): boolean;
    static distinct(array: any[]): any[];
    static distinctBy(array: any[], key: string): any[];
}

declare class BooleanExtension {
    static toBoolean(value: any): boolean;
}

declare enum DateCompareOption {
    Full = 0,
    Date = 1,
    Time = 2
}
declare class DateExtension {
    static format(date: Date, format: string): string;
    static getDatePart(date: Date): Date;
    static addMinutes(date: Date, minutes: number): Date;
    static addHours(date: Date, hours: number): Date;
    static addDays(date: Date, days: number): Date;
    static toUtc(date: Date): Date;
    static fromUtc(date: Date | string, offset?: number): Date;
    static compare(date1: Date, date2: Date, option: DateCompareOption): boolean;
}

declare class ObjectExtension {
    static extend(base: object, extend: object): object;
}

declare class NumberExtension {
    static toRub(val: number): string;
    static toPercent(val: number): string;
}

declare class StringExtension {
    static copyClipboard(text: string): void;
    static nbspInsert(text: string): string;
    static padLeft(element: any, l: number, c: string): string;
    static isAllDigits(str: string): boolean;
    static truncatStr(text: string, length?: number): string;
    static translate(text: string): string;
    static innParse(val: string): string;
}

/**
 * A unique identifier.
 */
declare class Guid {
    private _id;
    /**
     * Returns an empty GUID.
     */
    static empty(): Guid;
    /**
     * Creates a new GUID.
     */
    static newGuid(): Guid;
    static parse(val: any): Guid;
    private static s4;
    /**
     * Creates a new GUID from a string or clones existing guid.
     */
    constructor(id: string | Guid);
    /**
     * Compares if two GUID's are equal.
     */
    equals(value: string | Guid): boolean;
    /**
     * Converts the GUID to a formatted string.
     *
     * Formats:
     *   n = 00000000000000000000000000000000
     *   d = 00000000-0000-0000-0000-000000000000 (default)
     *   b = {00000000-0000-0000-0000-000000000000}
     */
    toString(format?: string): string;
    /**
     * Returns the underlying value.
     */
    valueOf(): string;
}

declare class RuDateAdapter extends NativeDateAdapter {
    private _devimetr;
    parse(value: any): Date | null;
    getFirstDayOfWeek(): number;
    format(date: Date, displayFormat: string): string;
    createDate(year: number, month: number, date: number): Date;
    private _to2digit;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuDateAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuDateAdapter>;
}
declare const APP_DATE_FORMATS: {
    parse: {
        dateInput: {
            month: string;
            year: string;
            day: string;
        };
    };
    display: {
        dateInput: string;
        monthYearLabel: string;
        dateA11yLabel: {
            year: string;
            month: string;
            day: string;
        };
        monthYearA11yLabel: {
            year: string;
            month: string;
        };
    };
};

declare class CoreUrlSerializer implements UrlSerializer {
    parse(url: any): UrlTree;
    serialize(tree: UrlTree): any;
}

declare enum AvatarEntity {
    User = 1,
    Chat = 2
}
declare class CoreAvatarService {
    private _ajaxM;
    private _startM;
    constructor(_ajaxM: AjaxService, _startM: Startup);
    avatarUpload(type: AvatarEntity, objectId: number, uploadFile: any): Observable<any>;
    avatarRemove(type: AvatarEntity, objectId: number): Observable<any>;
    avatarBackground(type: AvatarEntity, objectId: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAvatarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreAvatarService>;
}

declare abstract class CrudService<T> implements IQueryDataSertvice<T> {
    controller: string;
    app: string;
    _startUp: Startup;
    _ajaxM: AjaxService;
    constructor(controller: string, app: string, _startUp: Startup, _ajaxM: AjaxService);
    getDataSourceItems(query: string, params?: IQueryDataSertviceAdditionalParams): Observable<T[]>;
    getSingle(itemId: number | string): Observable<any>;
    save(item: T): Observable<any>;
    ban(itemId: number | string): Observable<any>;
    remove(itemId: number | string): Observable<any>;
}

interface IEventListener {
    ignore(): void;
}
interface IBrokeredEventBase {
    name: string;
    emit(data: any): void;
    listen(next: (data: any) => void): IEventListener;
}
interface IBrokeredEvent<T> extends IBrokeredEventBase {
    emit(data: any): void;
    listen(next: (data: any) => void): IEventListener;
}
declare class EventListener implements IEventListener {
    private _subscription;
    constructor(_subscription: Subscription);
    ignore(): void;
}
declare class BrokeredEvent<T> implements IBrokeredEvent<T> {
    name: string;
    private _subject;
    constructor(name: string);
    emit(data: T): void;
    listen(next: (value: T) => void): IEventListener;
}
declare class EventBrokerService {
    private _store;
    private _events;
    private readonly _storageKeyPrefix;
    private readonly _ttlMs;
    constructor(_store: BrowserSessionStorage);
    private _clearStoredEvents;
    private _register;
    private _getStorageKey;
    private _writeLastEvent;
    private _readLastEvent;
    listen<T>(eventName: string, next: (value: T) => void): IEventListener;
    emit<T>(eventName: string, data: T): void;
    /**
     * DOM-based event exchange: dispatch CustomEvent on target (window by default)
     */
    emitDom<T>(eventName: string, data: T, target?: EventTarget): void;
    /**
     * DOM-based event exchange: listen CustomEvent from target (window by default)
     */
    listenDom<T>(eventName: string, next: (value: T) => void, target?: EventTarget): IEventListener;
    /**
     * Очистить сохранённое событие из sessionStorage для конкретного события
     * @param eventName - имя события для очистки
     */
    clearStoredEvent(eventName: string): void;
    /**
     * Очистить все сохранённые события из sessionStorage
     */
    clearAllStoredEvents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventBrokerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EventBrokerService>;
}

declare class ButtonLoadingService {
    static run(target: any): void;
    static stop(target: any): void;
}

declare class MfaProviderService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getBalance(): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MfaProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MfaProviderService>;
}

declare class SignalMainModel {
    key: string;
    subKey: string;
    json: any;
}
declare class SignalBaseService {
    protected _hubConnection: any;
    getHubUrl(userId: any): string;
    onReconnected(): Function;
    onReconnectedLogic(): Function;
    onReceived(): Function;
    onSent(): Function;
    onSentFail(): Function;
    onCantSent(): Function;
    startConnection(userId: number): void;
    checkAndStartConnection(): void;
    sendToHub(dto: any, method?: string, canSend?: boolean): void;
    addListener(target: string, callback: (data: any) => void): void;
}

/** Событие: переключить вкладку, в которой есть невалидный контрол (см. data-sln-invalid-form-tab-id на предке). */
declare const SLN_INVALID_FORM_TAB_ACTIVATE_EVENT = "sln-invalid-form-tab-activate";
interface SlnInvalidFormTabActivateDetail {
    tabId: string;
    sourceElement: HTMLElement;
}
declare class InvalidFormService {
    invalidFormLogicCall(containerSelector?: string): string[];
    private getSearchRoot;
    private isVisible;
    private dispatchInvalidFormTabActivate;
    private getInvalidFormHost;
    private getInvalidFormTabLabel;
    /**
     * Если невалидный контрол внутри строки правила (.sln-invalid-rule-row) и у строки задан атрибут label,
     * наименование для списка ошибок берётся из него; иначе возвращается null — дальше сработает обычная логика.
     */
    private getInvalidNameFromRuleRowLabel;
    private getInvalidControlNames;
    private applyHighlightAndShake;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvalidFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InvalidFormService>;
}

declare class Utility {
    static isEmpty(object: any): boolean;
    static serializeObj(obj: any): string;
    static removeByKey<T>(array: T[], first: IPair): T[];
    static removeByTwoKey<T>(array: T[], first: IPair, second: IPair): T[];
    static containsByKey<T>(array: T[], first: IPair): boolean;
    static containsByTwoKey<T>(array: T[], first: IPair, second: IPair): boolean;
    static compareByKey<T>(a: T, b: T, first: IPair): 0 | 1 | -1;
    static format(value: any, pattern: string): any;
}

/**
 * Cookie Storage
 */
declare class BrowserCookieStorage implements CookieStorage {
    private document;
    private documentIsAccessible;
    constructor(document: any);
    get length(): number;
    check(name: string): boolean;
    getItem(name: string): string;
    getTyped<T>(key: string): T;
    getAll(): {};
    key(index: number): string | null;
    setItem(name: string, value: string, expires?: number | Date, path?: string, domain?: string, secure?: boolean): void;
    removeItem(name: string, path?: string, domain?: string): void;
    clear(path?: string, domain?: string): void;
    private _getCookieArray;
    private _getCookieRegExp;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserCookieStorage, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserCookieStorage>;
}
declare abstract class CookieStorage extends AbstractStorage {
    abstract check(name: string): boolean;
    abstract getAll(): any;
    abstract clear(path?: string, domain?: string): void;
    abstract removeItem(name: string, path?: string, domain?: string): void;
    abstract setItem(name: string, value: string, expires?: number | Date, path?: string, domain?: string, secure?: boolean): void;
}

declare class PhoneNumberFormatter {
    static formatRuPhoneNumber(phone: string): string;
}

interface ISellanCoreAuthKonturToken {
    accessToken: string;
    refreshToken: string;
    expiresAt: number;
}

declare const KONTUR_AUTH_SUCCESS_MESSAGE_TYPE = "SELLAN_KONTUR_AUTH_SUCCESS";
declare class KonturAuthService {
    private _startUp;
    private _ajaxService;
    private _storage;
    constructor(_startUp: Startup, _ajaxService: AjaxService, _storage: BrowserLocalStorage);
    hasValidToken(): boolean;
    getAccessToken(): string;
    setToken(model: ISellanCoreAuthKonturToken): void;
    refreshToken(): void;
    loginRedirect(): void;
    loginKonturPopup(width: any, height: any): Promise<void>;
    private getRefreshToken;
    static ɵfac: i0.ɵɵFactoryDeclaration<KonturAuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KonturAuthService>;
}

declare const SLN_CORE_COMBOBOX_SOURCE = "ComboboxUriDescriptionService";
interface IComboboxUriDescriptionService {
    getUri(code: string, module?: string): string;
    getLocalSourse(code: string, filters?: Filtration): Observable<IEntityResponse>;
}
declare class DefaultComboboxUriDescriptionService implements IComboboxUriDescriptionService {
    getUri(code: string, module?: string): string;
    getLocalSourse(code: string, filters?: Filtration): Observable<IEntityResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultComboboxUriDescriptionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultComboboxUriDescriptionService>;
}

declare class CoreComboboxService {
    private _externalService;
    private _startUp;
    private _ajaxM;
    constructor(_externalService: IComboboxUriDescriptionService, _startUp: Startup, _ajaxM: AjaxService);
    loadValues(code: string, filter: Filtration, count?: number, module?: string): Observable<any>;
    private getUri;
    private _url;
    private getDictionary;
    private getRecordCount;
    private getLocalDictionary;
    private getConditions;
    private getValidToUnit;
    private _getSettingFieldTypes;
    private _getSimpleFieldTypes;
    private _getAdminParticipations;
    private _getDataSourceSelectorComboboxValues;
    private _getFileTypesVersionLevels;
    private _getDirectoryColumn;
    private _getFrequencyValues;
    private _getDaysOfWeek;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreComboboxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreComboboxService>;
}

declare class CoreFieldTypeComboboxComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit, AfterViewInit {
    private _comboboxService;
    private _onEmptyExpression;
    private _onEmptyForseReload;
    comboboxSelect: MatSelect;
    templateRef: TemplateRef<any>;
    _componentCombobox: UntypedFormControl;
    _componentComboboxFilter: UntypedFormControl;
    _filteredValues: ReplaySubject<ISimpleComboboxItem[]>;
    _filteredValuesData: ISimpleComboboxItem[];
    multiple: boolean;
    private _master;
    set master(v: ISimpleComboboxItem);
    dataSource: Observable<any>;
    excludedValues: ISimpleComboboxItem[];
    get isHasTemplate(): boolean;
    get emptyText(): string;
    get isTextEmpty(): boolean;
    constructor(_comboboxService: CoreComboboxService);
    private _setEmptyFilteredValues;
    registerOnValidatorChange?(fn: () => void): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    setDefault(): void;
    validate({ value }: UntypedFormControl): {
        [key: string]: any;
    };
    formatValue(model: any): any;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    onEmpty(expression?: FiltrationItem[], forse?: boolean): void;
    loadValues(expression?: FiltrationItem[], forse?: boolean, isFromFilterChange?: boolean): void;
    private internalLoadValues;
    private handleReadResult;
    onOpenedChange(isOpen: boolean): void;
    private setInitialValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeComboboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeComboboxComponent, "core-field-combobox", never, { "multiple": { "alias": "multiple"; "required": false; }; "master": { "alias": "master"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "excludedValues": { "alias": "excludedValues"; "required": false; }; }, {}, ["templateRef"], never, false, never>;
}
declare function scrollFactory(overlay: Overlay): () => NoopScrollStrategy;

declare class CoreFieldTypeMultipleComboboxComponent extends CoreFieldTypeComboboxComponent implements ControlValueAccessor, OnDestroy, OnInit, Validator, AfterViewInit {
    anyChecked: boolean;
    allComplete: boolean;
    constructor(_comboboxService: CoreComboboxService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    validate({ value }: UntypedFormControl): {
        [key: string]: any;
    };
    changeComboBoxValue($event: any): void;
    onOpenedChange(isOpen: boolean): void;
    getChipValue({ text }: {
        text: any;
    }): any;
    someComplete(): boolean;
    updateAllComplete(): void;
    unselectItem(item: any): void;
    selectAll($event: any): void;
    private setInitialMultiValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeMultipleComboboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeMultipleComboboxComponent, "core-field-multiple-combobox", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldTypeDateTimeComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit, OnChanges {
    private _cd;
    _maskedInput: ElementRef;
    _dateInput: ElementRef;
    mask?: string;
    constructor(_cd: ChangeDetectorRef);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    ngOnChanges(changes: SimpleChanges): void;
    dispatch(input: HTMLInputElement): void;
    onValueChangeMaskInput(model: any): void;
    dateIsValid(date: any, model: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeDateTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeDateTimeComponent, "core-field-date", never, { "mask": { "alias": "mask"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreFieldTypeTimeComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    private _cd;
    _maskedInput: ElementRef;
    _dateInput: ElementRef;
    constructor(_cd: ChangeDetectorRef);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    dispatch(input: HTMLInputElement): void;
    onValueChangeMaskInput(model: any): void;
    dateIsValid(date: any, model: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeTimeComponent, "core-field-time", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldTypeNumberComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    isInt: boolean;
    constructor();
    ngOnInit(): void;
    setDefault(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeNumberComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeNumberComponent, "core-field-number", never, { "isInt": { "alias": "isInt"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreFieldTypeStringComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeStringComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeStringComponent, "core-field-string", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldTypeTextareaComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTypeTextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTypeTextareaComponent, "core-field-textarea", never, {}, {}, never, never, false, never>;
}

declare class CoreUserIconComponent extends CoreAbstractComponent {
    requestLitter: string;
    surnameLetter: string;
    nameLetter: string;
    fullNameValue: string;
    useInChat: boolean;
    sizeSuffix: string;
    url: string;
    backColor: string;
    set fullName(value: string);
    get avatarStyle(): Object;
    letterNumber(ch: any): any;
    getColorString(letter1: string, letter2: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreUserIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreUserIconComponent, "core-user-icon", never, { "useInChat": { "alias": "useInChat"; "required": false; }; "sizeSuffix": { "alias": "sizeSuffix"; "required": false; }; "url": { "alias": "url"; "required": false; }; "backColor": { "alias": "backColor"; "required": false; }; "fullName": { "alias": "fullName"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreFieldInnComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldInnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldInnComponent, "core-field-inn", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldKppComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldKppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldKppComponent, "core-field-kpp", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldOgrnComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldOgrnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldOgrnComponent, "core-field-ogrn", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldPasswordComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    makeValidation: boolean;
    hidePassword: boolean;
    hideConfirm: boolean;
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldPasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldPasswordComponent, "core-field-password", never, { "makeValidation": { "alias": "makeValidation"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreFieldSnilsComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldSnilsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldSnilsComponent, "core-field-snils", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldColorComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    insertColor(val: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldColorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldColorComponent, "core-field-color", never, {}, {}, never, never, false, never>;
}

declare class CoreLabelComponent extends CoreAbstractComponent implements OnInit {
    text: string;
    length: number;
    hasButton: boolean;
    get value(): string;
    ngOnInit(): void;
    copy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreLabelComponent, "core-label", never, { "text": { "alias": "text"; "required": false; }; "length": { "alias": "length"; "required": false; }; "hasButton": { "alias": "hasButton"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CardPanelComponent extends CoreAbstractComponent {
    panel: IPanel;
    buttonsTop: boolean;
    edit: EventEmitter<void>;
    get viewFooter(): boolean;
    onEditClick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardPanelComponent, "core-card-panel", never, { "panel": { "alias": "panel"; "required": false; }; "buttonsTop": { "alias": "buttonsTop"; "required": false; }; }, { "edit": "edit"; }, never, ["[header]", "[body]"], false, never>;
}

declare class CardEditButtonsComponent extends CoreAbstractComponent implements OnInit {
    private _formIsReadonly;
    formIsReadonlyChange: EventEmitter<boolean>;
    set formIsReadonly(formIsReadonly: boolean);
    get formIsReadonly(): boolean;
    saveAction: Function;
    cancelAction: Function;
    editButton: IButton;
    saveButton: IButton;
    cancelButton: IButton;
    constructor();
    ngOnInit(): void;
    private hiddenAction;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardEditButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardEditButtonsComponent, "core-card-edit-buttons", never, { "formIsReadonly": { "alias": "formIsReadonly"; "required": false; }; "saveAction": { "alias": "saveAction"; "required": false; }; "cancelAction": { "alias": "cancelAction"; "required": false; }; }, { "formIsReadonlyChange": "formIsReadonlyChange"; }, never, never, false, never>;
}

declare class CoreFieldIpComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, OnDestroy, OnInit {
    withSubnetMask: boolean;
    pattern: string;
    mask: string;
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldIpComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldIpComponent, "core-field-ip", never, { "withSubnetMask": { "alias": "withSubnetMask"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RuDatePipe implements PipeTransform {
    transform(value: Date, args?: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RuDatePipe, "dateRu", false>;
}

declare class RuDateTimePipe implements PipeTransform {
    transform(value: Date | string, args?: any): string;
    getCurrentDateWithUtcTimeValues(date: Date): Date;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuDateTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RuDateTimePipe, "dateTimeRu", false>;
}

declare class DateAndTimePipe implements PipeTransform {
    private months;
    transform(value: Date | string | number | null | undefined): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateAndTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateAndTimePipe, "todayDate", false>;
}

declare class ConversionDatePipe implements PipeTransform {
    transform(value: number): string;
    isLeapYear(year: number): boolean;
    getYearDays(year: number): number;
    getDaysInMonth(year: number, monthIndex: number): number;
    getSuffixForYears(num: number): string;
    getSuffixForMounth(num: number): string;
    getSuffixForDays(days: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConversionDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ConversionDatePipe, "conversionDate", false>;
}

declare class PhoneRuPipe implements PipeTransform {
    transform(rawNum: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneRuPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PhoneRuPipe, "phoneRu", false>;
}

declare class BooleanPipe implements PipeTransform {
    transform(value: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BooleanPipe, "boolean", false>;
}

declare class SafePipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(url: any): _angular_platform_browser.SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
}

declare class PrettyPrintJsonStringPipe implements PipeTransform {
    transform(value: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrettyPrintJsonStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PrettyPrintJsonStringPipe, "prettyprintJsonString", false>;
}

declare class FilterCmbxPipe implements PipeTransform {
    transform(items: ISimpleComboboxItem[], filter: number | string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCmbxPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterCmbxPipe, "filterCmbx", false>;
}

declare class ZeroLeftPadPipe implements PipeTransform {
    transform(value: any, args?: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZeroLeftPadPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ZeroLeftPadPipe, "zero", false>;
}

interface IMaskedValue {
    origin: string;
    expression: string;
    result: string;
}
declare class MaskPipe implements PipeTransform {
    maskedChars: string[];
    transform(value: string, mask: string): string;
    parse(value: string, mask: string): string;
    masked(value: string, maskTemplate: string): IMaskedValue;
    unmasked(value: string, maskTemplate: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MaskPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MaskPipe, "mask", false>;
}

declare class MoneyPipe implements PipeTransform {
    private DECIMAL_SEPARATOR;
    private THOUSANDS_SEPARATOR;
    constructor();
    transform(value: number | string, fractionSize?: number): string;
    parse(value: string, fractionSize?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoneyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoneyPipe, "money", false>;
}

declare class MiddleEllipsisPipe implements PipeTransform {
    private readonly defaultMaxLength;
    private readonly ellipsis;
    transform(value: string | null | undefined, maxLength?: number | null): string;
    private resolveMaxLength;
    static ɵfac: i0.ɵɵFactoryDeclaration<MiddleEllipsisPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MiddleEllipsisPipe, "middleEllipsis", false>;
}

declare class ProportionPercentPipe implements PipeTransform {
    constructor();
    transform(value: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionPercentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ProportionPercentPipe, "proportion", false>;
}

declare class PercentTransformPipe extends MoneyPipe implements PipeTransform {
    transform(value: number | string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentTransformPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PercentTransformPipe, "percentTransform", false>;
}

declare class CorePipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CorePipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CorePipeModule, [typeof RuDatePipe, typeof RuDateTimePipe, typeof DateAndTimePipe, typeof ConversionDatePipe, typeof PhoneRuPipe, typeof BooleanPipe, typeof SafePipe, typeof PercentTransformPipe, typeof ProportionPercentPipe, typeof MaskPipe, typeof MiddleEllipsisPipe, typeof ZeroLeftPadPipe, typeof MoneyPipe, typeof FilterCmbxPipe, typeof PrettyPrintJsonStringPipe], never, [typeof RuDatePipe, typeof RuDateTimePipe, typeof ConversionDatePipe, typeof DateAndTimePipe, typeof PhoneRuPipe, typeof SafePipe, typeof ZeroLeftPadPipe, typeof BooleanPipe, typeof PercentTransformPipe, typeof ProportionPercentPipe, typeof MaskPipe, typeof MiddleEllipsisPipe, typeof MoneyPipe, typeof FilterCmbxPipe, typeof PrettyPrintJsonStringPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CorePipeModule>;
}

declare class CollapseDirective {
    private height;
    private isExpanded;
    private isCollapsed;
    private isCollapse;
    private isCollapsing;
    private set collapse(value);
    private get collapse();
    constructor();
    toggle(): void;
    hide(): void;
    show(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseDirective, "[collapse]", never, { "collapse": { "alias": "collapse"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class CopyClipboardDirective implements OnDestroy {
    private el;
    tooltip: string;
    delay?: number;
    private _myPopup;
    onDblClick(event: MouseEvent): void;
    constructor(el: ElementRef);
    private createTooltipPopup;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CopyClipboardDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyClipboardDirective, "[copyClipboard]", never, { "tooltip": { "alias": "tooltip"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; }, {}, never, never, false, never>;
}

declare class EqualValidatorDirective implements Validator {
    validateEqual: string;
    reverse: string;
    constructor(validateEqual: string, reverse: string);
    private get isReverse();
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<EqualValidatorDirective, [{ attribute: "validateEqual"; }, { attribute: "reverse"; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EqualValidatorDirective, "[validateEqual][formControlName],[validateEqual][formControl],[validateEqual][ngModel]", never, {}, {}, never, never, false, never>;
}

declare class VerificationDirective implements Validator {
    private el;
    verification: boolean;
    private get isVerificated();
    constructor(el: ElementRef);
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<VerificationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VerificationDirective, "[verification]", never, { "verification": { "alias": "verification"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DigitMaxDirective implements Validator {
    private el;
    max: number;
    constructor(el: ElementRef);
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DigitMaxDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DigitMaxDirective, "[max]", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DigitMinDirective implements Validator {
    private el;
    min: number;
    constructor(el: ElementRef);
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DigitMinDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DigitMinDirective, "[min]", never, { "min": { "alias": "min"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PasswordValidatorDirective implements Validator {
    private MIN_LENGTH;
    passwordCheck: boolean;
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PasswordValidatorDirective, "[passwordCheck]", never, { "passwordCheck": { "alias": "passwordCheck"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SnilsDirective implements Validator {
    private el;
    constructor(el: ElementRef);
    private _checkSum;
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<SnilsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SnilsDirective, "[snils]", never, {}, {}, never, never, false, never>;
}

declare class InnDirective implements Validator {
    private el;
    constructor(el: ElementRef);
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    private _checkInn;
    static ɵfac: i0.ɵɵFactoryDeclaration<InnDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InnDirective, "[inn]", never, {}, {}, never, never, false, never>;
}

interface FileHandle {
    file: File;
    url: SafeUrl;
}
declare class DragUploudDirective {
    private sanitizer;
    files: EventEmitter<FileHandle[]>;
    constructor(sanitizer: DomSanitizer);
    private background;
    onDragOver(evt: DragEvent): void;
    onDragLeave(evt: DragEvent): void;
    onDrop(evt: DragEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragUploudDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DragUploudDirective, "[dragUpload]", never, {}, { "files": "files"; }, never, never, false, never>;
}

declare class MatContextMenuTrigger extends MatMenuTrigger implements OnDestroy {
    get menu_again(): MatMenuPanel;
    set menu_again(menu: MatMenuPanel);
    set ignoredMenu(value: any);
    _handleMousedown(event: MouseEvent): void;
    _handleClick(event: MouseEvent): void;
    private hostElement;
    _handleContextMenu(event: MouseEvent): void;
    private contextListenerSub;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatContextMenuTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatContextMenuTrigger, "[matContextMenuTriggerFor]", ["matContextMenuTrigger"], { "menu_again": { "alias": "matContextMenuTriggerFor"; "required": false; }; "ignoredMenu": { "alias": "matMenuTriggerFor"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HotkeyDirective {
    hotkey: string;
    hotkeyCtrl: boolean;
    hotkeyShift: boolean;
    hotkeyAlt: boolean;
    hotkeyPressed: EventEmitter<void>;
    onKeyDown(event: KeyboardEvent): void;
    private matchesHotkey;
    static ɵfac: i0.ɵɵFactoryDeclaration<HotkeyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HotkeyDirective, "[hotkey]", never, { "hotkey": { "alias": "hotkey"; "required": false; }; "hotkeyCtrl": { "alias": "hotkeyCtrl"; "required": false; }; "hotkeyShift": { "alias": "hotkeyShift"; "required": false; }; "hotkeyAlt": { "alias": "hotkeyAlt"; "required": false; }; }, { "hotkeyPressed": "hotkeyPressed"; }, never, never, false, never>;
}

declare class CoreDirectiveModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDirectiveModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDirectiveModule, [typeof CollapseDirective, typeof RequiredFileValidatorDirective, typeof CopyClipboardDirective, typeof EqualValidatorDirective, typeof VerificationDirective, typeof DigitMaxDirective, typeof DigitMinDirective, typeof PasswordValidatorDirective, typeof SnilsDirective, typeof InnDirective, typeof DragUploudDirective, typeof MatContextMenuTrigger, typeof HotkeyDirective], never, [typeof CollapseDirective, typeof CopyClipboardDirective, typeof RequiredFileValidatorDirective, typeof EqualValidatorDirective, typeof VerificationDirective, typeof DigitMaxDirective, typeof DigitMinDirective, typeof PasswordValidatorDirective, typeof SnilsDirective, typeof InnDirective, typeof DragUploudDirective, typeof MatContextMenuTrigger, typeof HotkeyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDirectiveModule>;
}

declare class CoreControlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreControlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreControlModule, [typeof CoreSelectSearchComponent, typeof ExternalRedirectComponent, typeof CoreFieldTypeBoolComponent, typeof CoreFieldTypeComboboxComponent, typeof CoreFieldTypeMultipleComboboxComponent, typeof CoreFieldTypeDateTimeComponent, typeof CoreFieldTypeTimeComponent, typeof CoreFieldTypeNumberComponent, typeof CoreFieldTypeStringComponent, typeof CoreFieldTypeTextareaComponent, typeof CoreUserIconComponent, typeof CoreFieldInnComponent, typeof CoreFieldKppComponent, typeof CoreFieldOgrnComponent, typeof CoreFieldPasswordComponent, typeof CoreFieldSnilsComponent, typeof CoreFieldColorComponent, typeof CoreLabelComponent, typeof CardPanelComponent, typeof CardEditButtonsComponent, typeof CoreFieldIpComponent], [typeof CoreMatModule, typeof CoreBaseModule, typeof CorePipeModule, typeof CoreDirectiveModule, typeof i26$1.NgxMaskDirective, typeof i26$1.NgxMaskPipe], [typeof CoreUserIconComponent, typeof CoreSelectSearchComponent, typeof ExternalRedirectComponent, typeof CoreFieldTypeBoolComponent, typeof CoreFieldTypeComboboxComponent, typeof CoreFieldTypeDateTimeComponent, typeof CoreFieldTypeTimeComponent, typeof CoreFieldTypeNumberComponent, typeof CoreFieldTypeStringComponent, typeof CoreFieldTypeTextareaComponent, typeof CoreFieldTypeMultipleComboboxComponent, typeof CoreFieldInnComponent, typeof CoreFieldKppComponent, typeof CoreFieldOgrnComponent, typeof CoreFieldPasswordComponent, typeof CoreFieldSnilsComponent, typeof CoreFieldColorComponent, typeof CoreLabelComponent, typeof CardPanelComponent, typeof CardEditButtonsComponent, typeof CoreFieldIpComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreControlModule>;
}

declare class CoreAvatarCropperDialogWindow extends CoreBaseDestroyComponent implements OnInit {
    dialogRef: MatDialogRef<CoreAvatarCropperDialogWindow>;
    image: string;
    private sanitizer;
    sanitizedUrl: SafeUrl;
    constructor(dialogRef: MatDialogRef<CoreAvatarCropperDialogWindow>, image: string, sanitizer: DomSanitizer);
    ngOnInit(): void;
    eventA: any;
    croppedImage: any;
    imageCropped(event: ImageCroppedEvent): void;
    crop(): void;
    reset(): void;
    private _getRoundedCanvas;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAvatarCropperDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAvatarCropperDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class DialogConfirmReason {
    static cancel: string;
}
interface ConfirmDialogOptions {
    message?: string;
    button?: string;
    cancel?: string;
}
declare class CoreConfirmDialogWindow extends CoreAbstractComponent implements OnInit {
    dialogRef: MatDialogRef<CoreConfirmDialogWindow>;
    data: ConfirmDialogOptions;
    beforeClosed: Function;
    constructor(dialogRef: MatDialogRef<CoreConfirmDialogWindow>, data: ConfirmDialogOptions);
    onEsc(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreConfirmDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreConfirmDialogWindow, "ng-component", never, { "beforeClosed": { "alias": "beforeClosed"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum InfoType {
    Success = "success",
    Danger = "danger",
    Warning = "warning",
    Info = "info",
    ValidationError = "validation"
}
declare class InfoDiologConfig {
    type: InfoType;
    message?: string;
    constructor(type: InfoType, message: string);
}
declare class CoreInfoDialogWindow extends CoreAbstractComponent implements AfterViewInit, OnInit {
    dialogRef: MatDialogRef<CoreInfoDialogWindow>;
    data: InfoDiologConfig;
    dialogTitle: string;
    constructor(dialogRef: MatDialogRef<CoreInfoDialogWindow>, data: InfoDiologConfig);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreInfoDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreInfoDialogWindow, "core-info-dialog", never, {}, {}, never, never, false, never>;
}

declare class DialogReason {
    static cancel: string;
}
interface DialogResult {
    state: string;
    emmiter: string;
}
declare class CoreDialogWindow extends CoreAbstractComponent implements OnInit {
    private _dialogRef;
    dialogTitle: string;
    hasCansel: boolean;
    canselText: string;
    hasFooter: boolean;
    fullScreen: boolean;
    width: number;
    minWidth: number;
    hasTitle: boolean;
    leftMenu: boolean;
    resizeble: boolean;
    showTicketsVersions: boolean;
    showCloseConfirmDialog: boolean;
    beforeClosed: Function;
    cdkDragDisabled: boolean;
    private matDialogRef;
    toggTicketsVersions(): void;
    styleWidth(): Object;
    constructor(_dialogRef: MatDialogRef<CoreDialogWindow>);
    onKeyUp(): void;
    ngOnInit(): void;
    prepareDialogNativeElement(): void;
    close($event: any): void;
    private _closingLogic;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDialogWindow, "core-dialog", never, { "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "hasCansel": { "alias": "hasCansel"; "required": false; }; "canselText": { "alias": "canselText"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "fullScreen": { "alias": "fullScreen"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "hasTitle": { "alias": "hasTitle"; "required": false; }; "leftMenu": { "alias": "leftMenu"; "required": false; }; "resizeble": { "alias": "resizeble"; "required": false; }; "showTicketsVersions": { "alias": "showTicketsVersions"; "required": false; }; "showCloseConfirmDialog": { "alias": "showCloseConfirmDialog"; "required": false; }; "beforeClosed": { "alias": "beforeClosed"; "required": false; }; "cdkDragDisabled": { "alias": "cdkDragDisabled"; "required": false; }; }, {}, never, ["[ticketsVersionsMenu]", "[header]", "[body]", "[footer]"], false, never>;
}

declare class CoreDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDialogModule, [typeof CoreConfirmDialogWindow, typeof CoreInfoDialogWindow, typeof CoreDialogWindow], [typeof CoreMatModule, typeof i5$2.DragDropModule, typeof CoreControlModule, typeof CoreNotificationModule, typeof CoreBaseModule], [typeof CoreConfirmDialogWindow, typeof CoreInfoDialogWindow, typeof i5$2.DragDropModule, typeof CoreDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDialogModule>;
}

declare class CoreCropperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCropperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreCropperModule, [typeof CoreAvatarCropperDialogWindow], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreDialogModule, typeof CoreCropperJsModule], [typeof CoreAvatarCropperDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreCropperModule>;
}

declare class CoreCropperService {
    private _dialog;
    constructor(_dialog: MatDialog);
    uploadAvatar(uploadFunction: Function): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCropperService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreCropperService>;
}

declare class CoreDialog {
    static stack: any[];
    static notificate(msg: string, type?: InfoType): void;
    static confirm(action: Function, faild?: Function, options?: ConfirmDialogOptions): void;
    static window<T>(component: ComponentType<T>, data?: any, action?: Function, faild?: Function): MatDialogRef<T, any>;
    private static _pushStack;
    private static _popStack;
}

interface IPopupResultsOption {
    msg?: string;
    successCallback?: Function;
    failCallback?: Function;
}
interface PopupResultsOption extends IPopupResultsOption {
    response: IResponse;
}
interface PopupEntityResultsOption extends IPopupResultsOption {
    response: IEntityResponse;
}
declare class PopupResults {
    HandleIResponse(option: PopupResultsOption): void;
    HandleIEntityResponse(option: PopupEntityResultsOption): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopupResults, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PopupResults>;
}

declare const CORE_DRAWER_DATA_TOKEN_KEY: InjectionToken<DrawerConfig<any>>;
/** конфигурация по умолчанию  */
declare const CoreDawerBaseOverlayConfig: OverlayConfig;
interface DrawerEvent {
    name: string;
    data?: any;
}
declare class DrawerConfig<D = any> {
    name: string;
    data?: D | null;
    width?: string | number;
    overlayRef?: OverlayRef;
}
declare class DrawerService {
    private _overlay;
    private _parentInjector;
    private _eventBroker;
    private _appRef;
    private _overlayRefs;
    private _overlayConfig;
    constructor(_overlay: Overlay, _parentInjector: Injector, _eventBroker: EventBrokerService, _appRef: ApplicationRef);
    show<T, D = any>(component: Type<T>, config?: DrawerConfig<D>): void;
    close(name: string, data?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DrawerService>;
}

declare class CoreDrawerComponent extends CoreAbstractComponent implements OnInit {
    private _service;
    perfectScroll: NgScrollbar;
    name: string;
    titleHeight: number;
    footerHeight: number;
    dialogTitle: string;
    width: number;
    minWidth: number;
    hasTitle: boolean;
    hasFooter: boolean;
    private _goto;
    get goto(): number;
    set goto(value: number);
    reachedTopRun: EventEmitter<any>;
    reachedBottomRun: EventEmitter<any>;
    constructor(_service: DrawerService);
    onKeyUp(): void;
    onReachedTop(): void;
    onReachedBottom(): void;
    ngOnInit(): void;
    getMaxContentHeight(): Object;
    getMaxHeight(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDrawerComponent, "core-drawer", never, { "name": { "alias": "name"; "required": false; }; "titleHeight": { "alias": "titleHeight"; "required": false; }; "footerHeight": { "alias": "footerHeight"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "hasTitle": { "alias": "hasTitle"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "goto": { "alias": "goto"; "required": false; }; }, { "reachedTopRun": "reachedTopRun"; "reachedBottomRun": "reachedBottomRun"; }, never, ["[title]", "[body]", "[footer]"], false, never>;
}

declare class CoreDrawerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDrawerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDrawerModule, [typeof CoreDrawerComponent], [typeof i5$2.DragDropModule, typeof CoreMatModule, typeof CoreControlModule, typeof CoreNotificationModule, typeof CoreBaseModule], [typeof CoreDrawerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDrawerModule>;
}

declare class CoreGirdDynamicPipe implements PipeTransform {
    private _injector;
    constructor(_injector: Injector);
    transform(value: any, pipeToken: any, pipeArgs?: any[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGirdDynamicPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CoreGirdDynamicPipe, "dynamicPipe", false>;
}

declare enum Align {
    Left = 1,
    Center = 2,
    Right = 3
}
interface IDataGridComponentTemplate extends IFederationEntity {
    isRemote: boolean;
}
declare class DataGridComponentTemplate extends FederationEntity implements IDataGridComponentTemplate {
    isRemote: boolean;
    static isIDataGridComponentTemplate(component: Type<any> | IDataGridComponentTemplate): component is IDataGridComponentTemplate;
}
interface IDataGridColumn extends IExportedColumn {
    key: string;
    type: number;
    title: string;
    description?: string;
    pipeType?: string;
    order?: number;
    align?: Align;
    visible?: boolean;
    useSort?: boolean;
    sortKey?: string;
    useFilter?: boolean;
    filterAccess?: () => boolean;
    filterKey?: string;
    filterTitle?: string;
    filterCondition?: string;
    filterTemplate?: boolean;
    filterTemplateType?: Type<any> | IDataGridComponentTemplate;
    filterTemplateTypeInputs?: Map<string, any>;
    filterTemplateTypeOutputs?: Map<string, (row: any) => void>;
    columnAccess?: () => boolean;
    columnTemplate?: boolean;
    columnTemplateType?: Type<any> | IDataGridComponentTemplate;
    columnTemplateTypeInputs?: Map<string, any>;
    columnTemplateTypeOutputs?: Map<string, (row: any) => void>;
    columnTemplateHtml?: string;
    /**
    * @deprecated теперь метод рендеринга самостоятельно определяет ключи для подстановки в шаблон из шаблона
    */
    columnTemplateHtmlKeys?: string[];
    columnTemplateDepends?: IGridColumnDepend[];
    isExported?: boolean;
    exportAlternatives?: IExportedColumn[];
    checkRowContentFn?: (row: any) => boolean;
    checkPermissionFn?: () => boolean;
}
interface IGridColumnDepend {
    dataField: string | ISimpleComboboxItem;
}
interface IExportedColumn {
    exportKey?: string | ISimpleComboboxItem;
    exportType?: number | ISimpleComboboxItem;
    exportTitle?: string;
}

declare enum ExportMode {
    OnlyVisible = 1,
    All = 2
}
declare enum ViewMode {
    Default = 1,
    Card = 2
}
interface IViewCardModeSettings {
    cardClass?: string;
    cardTpl: () => TemplateRef<any>;
}
interface ICoreGridConfiguration {
    service: IQueryDataSertvice<any>;
    columns: IDataGridColumn[];
    useVariativeViewMode?: boolean;
    variativeViewMode?: ViewMode;
    viewCardModeSettings?: IViewCardModeSettings;
    objectId?: number;
    viewKey: string;
    notSaveFilters?: boolean;
    multiCommands?: boolean;
    multiCommandsAccess?: () => boolean;
    useExport?: boolean;
    exportAdditionalParamsFunc?: Function;
    userServerConfiguration?: boolean;
    useColumnsSettings?: boolean;
    useFiltersWindow?: boolean;
    useSelectLogic?: boolean;
    selectLogicKey?: string;
    selectLogicMode?: 'checkbox' | 'row';
    selectLogicRowView?: (row: any) => boolean;
    selectLogicAccess?: () => boolean;
    defaultPageSize?: number;
    defaultMatSortActive?: string;
    defaultMatSortDirection?: 'asc' | 'desc' | '';
    paginatorUsed?: boolean;
    paginatorPosition?: 'top' | 'bottom';
    aggregateUsed?: boolean;
    refreshButtonUsed?: boolean;
    expanded?: boolean;
    expandedElementTpl?: () => TemplateRef<any>;
    expandedFunction?: (row: any) => boolean;
    rowBackgroundFunction?: (row: any) => string;
    loadToolbarConfigurationFunc?: Function;
    loadAdditionalParamsFunc?: Function;
    loadGridConfigurationFunc?: Function;
    afterLoadingFunc?: Function;
    componentTemplateMap?: Map<string, Type<any>>;
    hideToolbar?: boolean;
}

interface IGridConfigurationSaved {
    userId?: number;
    systemObjectId: string;
    title?: string;
    pageSize?: number;
    columns: IDataGridColumn[] | any;
    filters?: IFilterItem[] | any;
    isUserView?: boolean;
    isSharedView?: boolean;
}
interface IStorageDataGridFilter {
    userId: number;
    systemObjectId: string;
    filters: IFilterItem[];
}
declare class StorageDataGridFilter implements IStorageDataGridFilter {
    userId: number;
    systemObjectId: string;
    filters: IFilterItem[];
    constructor(userId: number, objId: string, filters: IFilterItem[]);
}

declare class GridStoreService {
    private _storage;
    private _context;
    readonly GRID_STORE_KEY: string;
    constructor(_storage: BrowserLocalStorage, _context: ContextService);
    read(userView: string, notSaveFilters: boolean): IStorageDataGridFilter[];
    write(userView: string, filters?: IFilterItem[]): void;
    clear(userView: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GridStoreService>;
}

declare class CoreGridFiltersComponent {
    private _filterEvents;
    storage: IStorageDataGridFilter[];
    userView: string;
    smallSize: boolean;
    notSaveFilters: boolean;
    columns: IDataGridColumn[];
    componentTemplateMap?: Map<string, Type<any>>;
    changeFilterItems: EventEmitter<IFilterItem[]>;
    getStorageValue(field: string): IFilterItem[];
    getStorageCondition(column: IDataGridColumn): string;
    addFilterEvent($event: IFilterItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridFiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridFiltersComponent, "core-grid-filters", never, { "userView": { "alias": "userView"; "required": false; }; "smallSize": { "alias": "smallSize"; "required": false; }; "notSaveFilters": { "alias": "notSaveFilters"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "componentTemplateMap": { "alias": "componentTemplateMap"; "required": false; }; }, { "changeFilterItems": "changeFilterItems"; }, never, never, false, never>;
}

declare class CoreServerGridComponent extends CoreBaseDestroyComponent implements OnInit, AfterContentChecked, AfterViewInit, OnDestroy {
    private _injector;
    private _gridStoreService;
    _filtersComponent: CoreGridFiltersComponent;
    private _title;
    private _isSharedView;
    _isInit: boolean;
    _dataExportService: DataExportService;
    _displayedColumns: string[];
    _gridConfig: IGridConfiguration<any>;
    _dataSource: ServerSideDataSource<any>;
    _defaultFilters: IFilterItem[];
    _userFilters: IFilterItem[];
    _exportedColumns: IGridColumn[];
    _expandedElement: any;
    _progressHide: boolean;
    _progress: number;
    _selected: any[];
    _isAllSelected: boolean;
    _showOnlySelected: boolean;
    _lastSelectedRowIndex: number;
    private _settings;
    set settings(value: ICoreGridConfiguration);
    get settings(): ICoreGridConfiguration;
    selectItem: EventEmitter<string[]>;
    _paginator: MatPaginator;
    _sort: MatSort;
    topScroll: ElementRef;
    bottomScroll: ElementRef;
    get anyRecords(): boolean;
    get anyFilters(): boolean;
    get showMultiCommandsBtn(): boolean;
    loadGridConfiguration(): IGridConfiguration<any>;
    loadAdditionalParams(): IQueryDataSertviceAdditionalParams;
    loadToolbarConfiguration(): void;
    afterLoadingCallback(): void;
    constructor(_injector: Injector, _gridStoreService: GridStoreService);
    private _defaultSettings;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private _onInitStaticGrid;
    private _onInitDynamicGrid;
    private _onInitCommon;
    changeVariativeViewMode(mode: number): void;
    private _initGridMainConfiguration;
    private _refreshGrid;
    ngAfterContentChecked(): void;
    updateColumns(columns: IDataGridColumn[]): void;
    getViewKey(): string;
    setViewKey(viewName?: string): string;
    changePaginator($event: any): void;
    hasDataItems(): boolean;
    isAggregateVisible(): boolean;
    onWindowKeydown(event: KeyboardEvent): void;
    renderCustomHtmlTemplate(columnHtml: string, keys: string[], value: any): string;
    expandOnClick(row: any, event?: MouseEvent): void;
    directSelectCheckbox(event: MouseEvent, row: any): void;
    onCheckboxClick(event: MouseEvent, row: any): void;
    changeFilterItems(events: IFilterItem[]): void;
    multiRunEvent(): void;
    multiProgressEvent(event: number): void;
    multiFinishEvent(callback: Function): void;
    cell(element: any, key: string): string;
    getPosition(element: any, suffix: string): string;
    private _getSortField;
    initSortConfiguration(that: any): void;
    isSelectedRow(row: any): boolean;
    setIsAllSelected(): void;
    selectAll(event: any): void;
    canSelect(): boolean;
    shouldRenderCell(row: any, column: IDataGridColumn): boolean;
    private _selectRow;
    private _updateLastSelectedIndex;
    private _selectRange;
    refreshClick(): void;
    exportExcel(): void;
    showFilters(): void;
    clearStorageFilters(noNeedRefresh?: boolean): void;
    editColumns(): void;
    createUserView(): void;
    private _redirectToView;
    private _saveUserGridConfiguration;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreServerGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreServerGridComponent, "core-grid", never, { "settings": { "alias": "settings"; "required": false; }; }, { "selectItem": "selectItem"; }, never, ["[toolbarLeft]", "[toolbarRight]", "[multiCommands]"], false, never>;
}

declare class CoreGridColumnTemplateComponent implements AfterViewInit {
    private cdref;
    private static _moduleCache;
    private _isInit;
    component: Type<any> | IDataGridComponentTemplate;
    inputs?: Map<string, any>;
    outputs?: Map<string, (row: any) => void>;
    value: any;
    componentTemplateMap: Map<string, Type<any>>;
    refreshEvent: EventEmitter<any>;
    multiRunEvent: EventEmitter<any>;
    multiProgressEvent: EventEmitter<any>;
    multiFinishEvent: EventEmitter<any>;
    host: any;
    constructor(cdref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    render(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridColumnTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridColumnTemplateComponent, "core-grid-column-template", never, { "component": { "alias": "component"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; "value": { "alias": "value"; "required": false; }; "componentTemplateMap": { "alias": "componentTemplateMap"; "required": false; }; }, { "refreshEvent": "refreshEvent"; "multiRunEvent": "multiRunEvent"; "multiProgressEvent": "multiProgressEvent"; "multiFinishEvent": "multiFinishEvent"; }, never, never, false, never>;
}

declare class CoreGridFilterTemplateComponent implements AfterViewInit, OnChanges {
    private cdref;
    title: string;
    columnDef: string;
    condition: string;
    useTemplate: boolean;
    component: any;
    dataType: number;
    componentTemplateMap: Map<string, Type<any>>;
    inputs?: Map<string, any>;
    outputs?: Map<string, (row: any) => void>;
    smallSize: boolean;
    changeFilterItem: EventEmitter<any>;
    refreshEvent: EventEmitter<any>;
    initEvent: EventEmitter<any>;
    host: any;
    greaterThanOrEqualTo: CoreFieldTypeDateTimeComponent;
    lessThanOrEqualTo: CoreFieldTypeDateTimeComponent;
    private _refComponent;
    private _valueInitialized;
    private _value;
    get value(): IFilterItem[];
    set value(value: IFilterItem[]);
    isInit: boolean;
    val: any;
    get isPositiveCondition(): boolean;
    constructor(cdref: ChangeDetectorRef);
    private _getDateFilterItem;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    changeValue($event: any, conditon?: string): void;
    changeDateValue($event: any, conditon?: string): void;
    changeCond(): void;
    render(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridFilterTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridFilterTemplateComponent, "core-grid-filter-template", never, { "title": { "alias": "title"; "required": false; }; "columnDef": { "alias": "columnDef"; "required": false; }; "condition": { "alias": "condition"; "required": false; }; "useTemplate": { "alias": "useTemplate"; "required": false; }; "component": { "alias": "component"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; "componentTemplateMap": { "alias": "componentTemplateMap"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; "smallSize": { "alias": "smallSize"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "changeFilterItem": "changeFilterItem"; "refreshEvent": "refreshEvent"; "initEvent": "initEvent"; }, never, never, false, never>;
}

declare class CoreGridDialogFilterComponent implements AfterViewInit {
    private _dialogRef;
    data: any;
    private _storage;
    _filtersComponent: CoreGridFiltersComponent;
    columns: Array<any>;
    filterItems: IFilterItem[];
    userView: string;
    beforeClosed: Function;
    componentTemplateMap: Map<string, Type<any>>;
    init: boolean;
    filtersWasChanged: boolean;
    constructor(_dialogRef: MatDialogRef<CoreGridDialogFilterComponent>, data: any);
    ngAfterViewInit(): void;
    apply(): void;
    changeFilterItems(event: IFilterItem[]): void;
    resetFilters(): void;
    private _handleBeforClosed;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridDialogFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridDialogFilterComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

interface IGridViewConfig {
    isEditable?: boolean;
    creator?: ISimpleComboboxItem;
    title: string;
    key?: string;
    needShare: boolean;
    useForAll: boolean;
    users?: ISimpleComboboxItem[];
    useAdminList: boolean;
    adminList: ISimpleComboboxItem[];
}
declare class CoreUserViewDialogWindow implements OnInit {
    private _dialogRef;
    data: IGridViewConfig;
    private _context;
    view: IGridViewConfig;
    get isCanShare(): boolean;
    constructor(_dialogRef: MatDialogRef<CoreUserViewDialogWindow>, data: IGridViewConfig, _context: ContextService);
    ngOnInit(): void;
    onNeedShareChange(event: boolean): void;
    onUseForAllChange(event: boolean): void;
    onUseAdminListChange(event: boolean): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreUserViewDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreUserViewDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class GridConfigutarionService {
    private _startUp;
    private _ajaxM;
    private _context;
    constructor(_startUp: Startup, _ajaxM: AjaxService, _context: ContextService);
    getGrid(viewKey: string): Observable<any>;
    getUserView(key: string): Observable<any>;
    getUserColumn(systemObjectId: string): Observable<any>;
    saveUserColumn(data: IGridConfigurationSaved): Observable<any>;
    saveOrganizationColumn(subKey: string, view: IGridViewConfig): Observable<any>;
    deleteOrganizationColumn(viewName: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridConfigutarionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GridConfigutarionService>;
}

declare class CoreGridConfigUserColumnDialogWindow extends CoreBaseDestroyComponent implements OnInit {
    dialogRef: MatDialogRef<CoreGridConfigUserColumnDialogWindow>;
    data: any;
    private _dataService;
    private _popup;
    visible: IDataGridColumn[];
    hide: IDataGridColumn[];
    isInit: boolean;
    getMaxContentHeight(): Object;
    constructor(dialogRef: MatDialogRef<CoreGridConfigUserColumnDialogWindow>, data: any, _dataService: GridConfigutarionService, _popup: PopupResults);
    ngOnInit(): void;
    getViewKey(): string;
    save(): void;
    drop(event: CdkDragDrop<string[]>): void;
    onAlignChange($event: number, item: IDataGridColumn): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridConfigUserColumnDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridConfigUserColumnDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreGridExportModeDialogWindow {
    private _dialogRef;
    mode: ExportMode;
    constructor(_dialogRef: MatDialogRef<CoreGridExportModeDialogWindow>);
    okClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridExportModeDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridExportModeDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

interface IOrganizationItem {
    id: number;
    uid: string;
    created: Date;
    createdByFio?: string;
    organizationName: string;
    organizationShortName: string;
    okopf: ISimpleComboboxItem;
    inn: string;
    kpp?: string;
    ogrn: string;
    uniqueCode?: string;
    phone?: string;
    email?: string;
    extension?: IOrganizationItemExtension;
    organizationTypes?: IOrganizationItemTypes;
    parentId?: number;
    enabled: boolean;
    isVerified: boolean;
    systemType: string;
}
interface IOrganizationItemTypes {
    isSystem: boolean;
    isClient: boolean;
    isOperator: boolean;
    isBroker: boolean;
    isFinancial: boolean;
    isBank: boolean;
    isMallManagement: boolean;
    isLogistic: boolean;
}
declare class OrganizationItemTypes {
    isSystem: boolean;
    isClient: boolean;
    isOperator: boolean;
    isBroker: boolean;
    isFinancial: boolean;
    isBank: boolean;
    isMallManagement: boolean;
    isLogistic: boolean;
}
interface IOrganizationItemExtension {
    chiefExecutiveTitle?: string;
    chiefExecutiveFirstName?: string;
    chiefExecutiveMiddleName?: string;
    chiefExecutiveLastName?: string;
    chiefExecutiveBaseOn?: string;
}
declare class OrganizationItemExtension implements IOrganizationItemExtension {
    chiefExecutiveTitle?: string;
    chiefExecutiveFirstName?: string;
    chiefExecutiveMiddleName?: string;
    chiefExecutiveLastName?: string;
    chiefExecutiveBaseOn?: string;
}
declare class OrganizationItem implements IOrganizationItem {
    id: number;
    uid: string;
    created: Date;
    createdByFio?: string;
    organizationName: string;
    organizationShortName: string;
    okopf: ISimpleComboboxItem;
    inn: string;
    kpp?: string;
    ogrn: string;
    uniqueCode?: string;
    phone?: string;
    email?: string;
    extension?: IOrganizationItemExtension;
    organizationTypes?: IOrganizationItemTypes;
    parentId?: number;
    enabled: boolean;
    isVerified: boolean;
    systemType: string;
    constructor();
}

declare class OrganizationSearchResult {
    organizationId: number;
    organizationName: string;
    organizationShortName: string;
    inn: string;
    kpp?: string;
    ogrn: string;
    okopf?: ISimpleComboboxItem;
    firstName: string;
    middleName: string;
    lastName: string;
}

declare class IOrgnizationDialogOptions {
    item: IOrganizationItem;
    readonlyMode: boolean;
}
declare class CoreOrganizationDialogWindow extends CoreAbstractComponent {
    private dialogRef;
    data: IOrgnizationDialogOptions;
    get isEmptyValue(): boolean;
    get isDisabled(): boolean;
    get isIp(): boolean;
    setting: IFieldSetting;
    constructor(dialogRef: MatDialogRef<CoreOrganizationDialogWindow>, data: IOrgnizationDialogOptions);
    onSearchClick(data: OrganizationSearchResult): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreOrganizationDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreOrganizationDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldOrganizationComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit {
    private _dialog;
    get isImageEmpty(): boolean;
    constructor(_dialog: MatDialog);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    editValue(): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldOrganizationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldOrganizationComponent, "core-field-orgnization", never, {}, {}, never, never, false, never>;
}

interface Location {
    country?: string;
    country_iso_code?: string;
    region?: string;
    area?: string;
    city?: string;
    street?: string;
    street_type_full?: string;
    settlement_type_full?: string;
    city_district_type_full?: string;
    city_type_full?: string;
    area_type_full?: string;
    region_type_full?: string;
    kladr_id?: string;
    region_fias_id?: string;
    area_fias_id?: string;
    city_fias_id?: string;
    settlement_fias_id?: string;
    street_fias_id?: string;
}
declare enum DadataType {
    address = "address",
    bank = "bank",
    party = "party",
    fms = "fms_unit"
}
interface Bound {
    value: 'country' | 'region' | 'city' | 'street' | 'settlement' | 'area' | 'house';
}
declare enum Division {
    administrative = "administrative",
    municipal = "municipal"
}
interface Bounds {
    fromBound?: Bound;
    toBound?: Bound;
}
interface DadataConfig {
    type?: DadataType;
    delay?: number;
    limit?: number;
    width?: 'auto' | string;
    minWidth?: '0' | string;
    partyAddress?: 'city' | 'full';
    locations?: Location[];
    locationsBoost?: Location[];
    bounds?: Bounds;
    division?: Division;
}
declare const DadataConfigDefault: DadataConfig;

interface DadataAddress {
    postal_code: string | null;
    country: string | null;
    country_iso_code: string | null;
    region_fias_id: string | null;
    region_kladr_id: string | null;
    region_with_type: string | null;
    region_type: string | null;
    region_type_full: string | null;
    region: string | null;
    area_fias_id: string | null;
    area_kladr_id: string | null;
    area_with_type: string | null;
    area_type: string | null;
    area_type_full: string | null;
    area: string | null;
    city_fias_id: string | null;
    city_kladr_id: string | null;
    city_with_type: string | null;
    city_type: string | null;
    city_type_full: string | null;
    city: string | null;
    city_area: string | null;
    city_district_fias_id: string | null;
    city_district_kladr_id: string | null;
    city_district_with_type: string | null;
    city_district_type: string | null;
    city_district_type_full: string | null;
    city_district: string | null;
    settlement_fias_id: string | null;
    settlement_kladr_id: string | null;
    settlement_with_type: string | null;
    settlement_type: string | null;
    settlement_type_full: string | null;
    settlement: string | null;
    street_fias_id: string | null;
    street_kladr_id: string | null;
    street_with_type: string | null;
    street_type: string | null;
    street_type_full: string | null;
    street: string | null;
    house_fias_id: string | null;
    house_kladr_id: string | null;
    house_type: string | null;
    house_type_full: string | null;
    house: string | null;
    block_type: string | null;
    block_type_full: string | null;
    block: string | null;
    flat_type: string | null;
    flat_type_full: string | null;
    flat: string | null;
    flat_area: string | null;
    square_meter_price: string | null;
    flat_price: string | null;
    postal_box: string | null;
    fias_id: string | null;
    fias_code: string | null;
    fias_level: string | null;
    fias_actuality_state: string | null;
    kladr_id: string | null;
    capital_marker: string | null;
    okato: string | null;
    oktmo: string | null;
    tax_office: string | null;
    tax_office_legal: string | null;
    timezone: string | null;
    geo_lat: string | null;
    geo_lon: string | null;
    beltway_hit: string | null;
    beltway_distance: string | null;
    metro: string | null;
    qc_geo: string | null;
    qc_complete: string | null;
    qc_house: string | null;
    history_values: [string | null];
    unparsed_parts: string | null;
    source: string | null;
    qc: string | null;
}
interface DadataBank {
    opf: {
        type: string | null;
        full: string | null;
        short: string | null;
    };
    name: {
        payment: string | null;
        full: string | null;
        short: string | null;
    };
    bic: string | null;
    inn: string | null;
    kpp: string | null;
    swift: string | null;
    okpo: string | null;
    correspondent_account: string | null;
    registration_number: string | null;
    rkc: {
        opf: {
            type: string | null;
            full: string | null;
            short: string | null;
        };
        name: {
            payment: string | null;
            full: string | null;
            short: string | null;
        };
        bic: string | null;
        swift: string | null;
        okpo: string | null;
        correspondent_account: string | null;
        registration_number: string | null;
        rkc: string | null;
        address: {
            value: string | null;
            unrestricted_value: string | null;
            data: string | null;
        };
        phone: string | null;
        state: {
            status: string | null;
            actuality_date: number | null;
            registration_date: number | null;
            liquidation_date: string | null;
        };
    };
    address: {
        value: string | null;
        unrestricted_value: string | null;
        data: DadataAddress;
    };
    phone: string | null;
    state: {
        status: string | null;
        actuality_date: number | null;
        registration_date: number | null;
        liquidation_date: string | null;
    };
}
interface DadataParty {
    kpp: string | null;
    capital: string | null;
    management: {
        name: string | null;
        post: string | null;
    };
    founders: string | null;
    managers: string | null;
    branch_type: string | null;
    branch_count: number | null;
    source: string | null;
    qc: string | null;
    hid: string | null;
    type: string | null;
    state: {
        status: string | null;
        actuality_date: number | null;
        registration_date: number | null;
        liquidation_date: null;
    };
    opf: {
        type: string | null;
        code: string | null;
        full: string | null;
        short: string | null;
    };
    name: {
        full_with_opf: string | null;
        short_with_opf: string | null;
        latinstring: null;
        full: string | null;
        short: string | null;
    };
    inn: string | null;
    ogrn: string | null;
    okpo: string | null;
    okved: string | null;
    okveds: string | null;
    authorities: string | null;
    documents: string | null;
    licenses: string | null;
    address: {
        value: string | null;
        unrestricted_value: string | null;
        data: DadataAddress;
    };
    phones: string | null;
    emails: string | null;
    ogrn_date: number | null;
    okved_type: string | null;
}
interface DadataFmsUnit {
    code: string | null;
    name: string | null;
    region_code: number | null;
    type: number | null;
}

interface DadataSuggestion {
    value: string;
    unrestricted_value: string;
    data: DadataAddress | DadataBank | DadataParty | DadataFmsUnit;
}
interface DadataSuggestionResponse {
    suggestions: DadataSuggestion[];
}

declare class DadataIntegrationService {
    private http;
    private _startup;
    constructor(http: HttpClient, _startup: Startup);
    getData(value: string, type: DadataType, config: DadataConfig): Observable<DadataSuggestionResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DadataIntegrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DadataIntegrationService>;
}

interface IAddress {
    addressId: number;
    addressType: ISimpleComboboxItem;
    organizationId?: number;
    personId?: number;
    fiasId?: string;
    fiasCode?: string;
    kladrCode?: string;
    fullAddress: string;
    okato: string;
    oktmo: string;
    postIndex: string;
    country: ISimpleComboboxItem;
    regionFiasId?: string;
    region: ISimpleComboboxItem;
    regionName?: string;
    districtFiasId?: string;
    district: string;
    districtType: string;
    cityFiasId?: string;
    city: string;
    localityFiasId?: string;
    locality: string;
    localityType: string;
    streetFiasId?: string;
    street: string;
    streetType: string;
    house: string;
    room: string;
    roomType: string;
    enabled: boolean;
}
declare class Address implements IAddress {
    addressId: number;
    addressType: ISimpleComboboxItem;
    organizationId?: number;
    personId?: number;
    fiasCode?: string;
    fullAddress: string;
    okato: string;
    oktmo: string;
    postIndex: string;
    country: ISimpleComboboxItem;
    region: ISimpleComboboxItem;
    regionName?: string;
    district: string;
    districtType: string;
    city: string;
    locality: string;
    localityType: string;
    street: string;
    streetType: string;
    house: string;
    room: string;
    roomType: string;
    enabled: boolean;
    constructor();
}

declare function createDaDataFmsValidator(value: any): (c: UntypedFormControl) => {
    rangeError: {
        given: any;
        expected: any;
    };
};
declare class CoreDadataSearchComponent extends CoreBaseDestroyComponent implements OnInit, ControlValueAccessor {
    private _integrationService;
    private r;
    private _cd;
    private elRef;
    private v;
    currentFocus: number;
    opened: boolean;
    data: DadataSuggestion[];
    config: DadataConfig;
    configChanged: EventEmitter<DadataConfig>;
    disabled: any;
    type: DadataType;
    limit: number;
    placeholder: string;
    locations: any;
    address: IAddress;
    selectedSuggestion: DadataSuggestion;
    selected: EventEmitter<DadataSuggestion>;
    inputValue: ElementRef;
    private inputString$;
    /** Unique ID to be used by autocomplete trigger's "aria-owns" property. */
    id: string;
    onTouched: () => void;
    propagateChange: any;
    validateFn: any;
    dadataEnableMunitipal: boolean;
    constructor(_integrationService: DadataIntegrationService, r: Renderer2, _cd: ChangeDetectorRef, elRef: ElementRef);
    get value(): any;
    set value(v: any);
    ngOnInit(): void;
    getData(value: string): void;
    onClick(e: MouseEvent, item: DadataSuggestion): void;
    onOutsideClick($event: MouseEvent): void;
    onArrowDown(): void;
    onArrowUp(): void;
    onEnter(event: KeyboardEvent): void;
    setFocus(id: number): void;
    removeFocus(id: number): void;
    writeValue(value: any): void;
    /**
     * Set the function to be called
     * when the control receives a change event.
     *
     * @param fn a function
     */
    registerOnChange(fn: any): void;
    /**
     * Set the function to be called
     * when the control receives a touch event.
     *
     * @param fn a function
     */
    registerOnTouched(fn: any): void;
    /**
     * Implements disabled state for this element
     *
     * @param isDisabled Disabled state flag
     */
    setDisabledState(isDisabled: boolean): void;
    onDivisionTypeChange($event: boolean): void;
    cleanForm(): void;
    asParty(obj: any): DadataParty;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDadataSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDadataSearchComponent, "core-dadata-search", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "locations": { "alias": "locations"; "required": false; }; "address": { "alias": "address"; "required": false; }; }, { "configChanged": "configChanged"; "selectedSuggestion": "selectedSuggestion"; "selected": "selected"; }, never, never, false, never>;
}

declare function createDaDataValidator(value: any): (c: UntypedFormControl) => {
    rangeError: {
        given: any;
        expected: any;
    };
};
declare class CoreDadataFmsCodeComponent extends CoreAbstractAccessorComponent implements OnInit, ControlValueAccessor, OnDestroy {
    private _integrationService;
    private r;
    private elRef;
    currentFocus: number;
    opened: boolean;
    data: DadataSuggestion[];
    config: DadataConfig;
    type: DadataType;
    limit: number;
    locations: any;
    selectedSuggestion: DadataSuggestion;
    selected: EventEmitter<DadataSuggestion>;
    inputValue: ElementRef;
    private inputString$;
    /** Unique ID to be used by autocomplete trigger's "aria-owns" property. */
    id: string;
    constructor(_integrationService: DadataIntegrationService, r: Renderer2, elRef: ElementRef);
    ngOnInit(): void;
    getData(value: string): void;
    onClick(e: MouseEvent, item: DadataSuggestion): void;
    onOutsideClick($event: MouseEvent): void;
    onArrowDown(): void;
    onArrowUp(): void;
    onEnter(event: KeyboardEvent): void;
    setFocus(id: number): void;
    removeFocus(id: number): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDadataFmsCodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDadataFmsCodeComponent, "core-dadata-fms-code", never, { "limit": { "alias": "limit"; "required": false; }; "locations": { "alias": "locations"; "required": false; }; }, { "selectedSuggestion": "selectedSuggestion"; "selected": "selected"; }, never, never, false, never>;
}

declare class CoreDaDataModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDaDataModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDaDataModule, [typeof CoreDadataSearchComponent, typeof CoreDadataFmsCodeComponent], [typeof CoreMatModule, typeof CoreBaseModule, typeof i26$1.NgxMaskDirective, typeof i26$1.NgxMaskPipe, typeof CoreControlModule, typeof CoreDirectiveModule], [typeof CoreDadataSearchComponent, typeof CoreDadataFmsCodeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDaDataModule>;
}

declare class OrganizationBaseService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    searchOrganization(inn: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationBaseService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OrganizationBaseService>;
}

declare class CoreOrganizationSearchComponent extends CoreBaseDestroyComponent implements OnInit {
    private _organizationService;
    private _popupResult;
    private _dialog;
    private _startUp;
    config: DadataConfig;
    placeholder: string;
    classes: string;
    searchInn: string;
    searchClick: EventEmitter<OrganizationSearchResult>;
    clearClick: EventEmitter<OrganizationSearchResult>;
    searchControl: CoreDadataSearchComponent;
    get useDadata(): boolean;
    constructor(_organizationService: OrganizationBaseService, _popupResult: PopupResults, _dialog: MatDialog, _startUp: Startup);
    clearSearch(): void;
    ngOnInit(): void;
    searchByInn(): void;
    onSelected(event: DadataSuggestion): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreOrganizationSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreOrganizationSearchComponent, "core-organization-search", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "classes": { "alias": "classes"; "required": false; }; }, { "searchClick": "searchClick"; "clearClick": "clearClick"; }, never, never, false, never>;
}

declare class CoreOrganizationInfoComponent implements OnInit {
    private _context;
    organization: IOrganizationItem;
    disabled: boolean;
    showExtension: boolean;
    editableTypes: boolean;
    isSystem: boolean;
    isNotTeam: boolean;
    constructor(_context: ContextService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreOrganizationInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreOrganizationInfoComponent, "core-organization-info", never, { "organization": { "alias": "organization"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showExtension": { "alias": "showExtension"; "required": false; }; "editableTypes": { "alias": "editableTypes"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum VerificationChannel {
    Email = 1,
    Sms = 2,
    Mobile = 4,
    Telegram = 5
}
type VerificationAskData = {
    channel: VerificationChannel;
    destination: string;
};
type VerificationAskDialogData = {
    showConfirmHint: boolean;
} & VerificationAskData;
type VerificationSave = {
    code?: string;
    challenge?: string;
} & VerificationAskData;
type VerificationAskResponse = {
    displayPhone?: string;
} & VerificationSave;
interface HintAdditionalData {
    displayPhone?: string;
    destination?: string;
}
declare enum VerificationFlow {
    Inbound = 0,
    Outbound = 1
}

declare class VerificationService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    verificationAsk(data: VerificationAskData): Observable<any>;
    verificationVerifySave(verification: VerificationSave): Observable<any>;
    copySubscriptions(channelId: number): Observable<any>;
    checkEmail(email: string): Observable<any>;
    checkPhone(phone: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VerificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VerificationService>;
}

declare class CoreAbstractVerificationComponent extends CoreAbstractAccessorComponent {
    _dialog: MatDialog;
    _verificationService: VerificationService;
    _popup: PopupResults;
    private _control;
    verificationData: VerificationAskData;
    isVerificated: boolean;
    confirmed: EventEmitter<any>;
    constructor(_dialog: MatDialog, _verificationService: VerificationService, _popup: PopupResults);
    _confirm(channel: VerificationChannel, saveSuccessCallback?: (data: VerificationAskData, successCallback?: Function) => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAbstractVerificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAbstractVerificationComponent, "ng-component", never, {}, { "confirmed": "confirmed"; }, never, never, false, never>;
}

declare class CoreFieldEmailComponent extends CoreAbstractVerificationComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor(dialog: MatDialog, verificationService: VerificationService, popup: PopupResults);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    confirmEmail(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldEmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldEmailComponent, "core-field-email", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldPhoneComponent extends CoreAbstractVerificationComponent implements ControlValueAccessor, OnDestroy, OnInit {
    private _cd;
    isPasteChange: boolean;
    constructor(dialog: MatDialog, verificationService: VerificationService, popup: PopupResults, _cd: ChangeDetectorRef);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    confirmPhone(): void;
    onValueChange(model: any): void;
    onPaste(event: ClipboardEvent): void;
    handlePasteString(str: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldPhoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldPhoneComponent, "core-field-phone", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldTelegramComponent extends CoreAbstractVerificationComponent implements ControlValueAccessor, OnDestroy, OnInit {
    constructor(dialog: MatDialog, verificationService: VerificationService, popup: PopupResults);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    confirmTelegram(): void;
    _saveVerification(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldTelegramComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldTelegramComponent, "core-field-telegram", never, {}, {}, never, never, false, never>;
}

declare class CoreVerificationDialogWindow extends CoreBaseDestroyComponent implements OnInit {
    private dialogRef;
    data: VerificationAskDialogData;
    private _registrationService;
    private _popupResult;
    private REPEAT_WAIT;
    hasFooter: boolean;
    waitRepeat: boolean;
    waitCount: number;
    dialogTitleValue: string;
    vm: VisualSettingManager;
    verificationFlow: VerificationFlow;
    additionalData: HintAdditionalData;
    model: VerificationSave;
    errorMessage: string;
    constructor(injector: Injector, dialogRef: MatDialogRef<CoreVerificationDialogWindow>, data: VerificationAskDialogData, _registrationService: VerificationService, _popupResult: PopupResults);
    ngOnInit(): void;
    repeat(): void;
    confirm(): void;
    private ask;
    protected readonly VerificationChannel: typeof VerificationChannel;
    protected readonly VerificationFlow: typeof VerificationFlow;
    protected readonly PhoneNumberFormatter: typeof PhoneNumberFormatter;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreVerificationDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreVerificationDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreContactVerificationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreContactVerificationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreContactVerificationModule, [typeof CoreFieldEmailComponent, typeof CoreFieldPhoneComponent, typeof CoreFieldTelegramComponent, typeof CoreVerificationDialogWindow], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreControlModule, typeof CoreDialogModule, typeof CoreDirectiveModule, typeof i26$1.NgxMaskDirective, typeof i26$1.NgxMaskPipe], [typeof CoreFieldEmailComponent, typeof CoreFieldPhoneComponent, typeof CoreFieldTelegramComponent, typeof CoreVerificationDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreContactVerificationModule>;
}

declare class CoreOrganizationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreOrganizationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreOrganizationModule, [typeof CoreOrganizationDialogWindow, typeof CoreFieldOrganizationComponent, typeof CoreOrganizationSearchComponent, typeof CoreOrganizationInfoComponent], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreDirectiveModule, typeof CoreControlModule, typeof CoreDialogModule, typeof CoreDaDataModule, typeof CoreContactVerificationModule], [typeof CoreOrganizationDialogWindow, typeof CoreFieldOrganizationComponent, typeof CoreOrganizationSearchComponent, typeof CoreOrganizationInfoComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreOrganizationModule>;
}

declare abstract class CoreGridFilterBaseComponent implements AfterViewInit {
    isComponentInit: boolean;
    smallSize: boolean;
    columnDef: string;
    condition: string;
    placeholder: string;
    changeFilterItem: EventEmitter<any>;
    private _valueInitialized;
    private _initValue;
    get initValue(): string | number | ISimpleComboboxItem;
    set initValue(value: string | number | ISimpleComboboxItem);
    get isPositiveCondition(): boolean;
    ngAfterViewInit(): void;
    private _initializeValue;
    protected _changeFilterItem(value?: any): void;
    protected abstract _getValue(): any;
    protected _componentLoaded(): boolean;
    protected _setStringValue(_: string): void;
    protected _setNumberValue(_: number): void;
    protected _setComboboxValue(_: ISimpleComboboxItem): void;
    protected _initializeCustomValue(_: any): void;
    protected _applyFilter(element: any, valueProcessor?: (element: any) => any): void;
    changeCond(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridFilterBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridFilterBaseComponent, "ng-component", never, { "smallSize": { "alias": "smallSize"; "required": false; }; "columnDef": { "alias": "columnDef"; "required": false; }; "condition": { "alias": "condition"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "initValue": { "alias": "initValue"; "required": false; }; }, { "changeFilterItem": "changeFilterItem"; }, never, never, true, never>;
}

declare class CoreFilterOrganizationComponent extends CoreGridFilterBaseComponent implements AfterViewInit {
    private _cd;
    searchControl: CoreOrganizationSearchComponent;
    organizationInn: string;
    constructor(_cd: ChangeDetectorRef);
    protected _getValue(): any;
    protected _setStringValue(value: string): void;
    onSearchClick(data: OrganizationSearchResult): void;
    onCleanClick($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFilterOrganizationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFilterOrganizationComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFilterOrganizationInternalComponent extends CoreGridFilterBaseComponent implements AfterViewInit {
    private _cd;
    searchControl: CoreFieldTypeComboboxComponent;
    organizationInn: ISimpleComboboxItem;
    constructor(_cd: ChangeDetectorRef);
    protected _getValue(): any;
    protected _setStringValue(value: string): void;
    protected _setComboboxValue(value: ISimpleComboboxItem): void;
    private _setInControlValue;
    onSearchClick(data: ISimpleComboboxItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFilterOrganizationInternalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFilterOrganizationInternalComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class DoubleScrollbarsComponent implements AfterViewInit, OnDestroy {
    private cdref;
    doubleScrollBarHorizontal: string;
    mainDiv: ElementRef;
    wrapperDiv: ElementRef;
    sentinel: ElementRef;
    isSticky: boolean;
    wrapper2scrollWidth: string;
    hasHorizontalScroll: boolean;
    private resizeObserver;
    private intersectionObserver;
    constructor(cdref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    updateWrapperWidth(): void;
    onWrapperScroll(): void;
    onMainScroll(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DoubleScrollbarsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DoubleScrollbarsComponent, "core-double-scrollbar", never, { "doubleScrollBarHorizontal": { "alias": "doubleScrollBarHorizontal"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class CoreGridAlignButtonsComponent implements OnInit {
    align: number;
    iconH: number;
    valuesChange: EventEmitter<any>;
    ngOnInit(): void;
    changeAlign(val: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridAlignButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreGridAlignButtonsComponent, "core-grid-align-buttons", never, { "align": { "alias": "align"; "required": false; }; "iconH": { "alias": "iconH"; "required": false; }; }, { "valuesChange": "valuesChange"; }, never, never, false, never>;
}

declare class CoreGridModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreGridModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreGridModule, [typeof CoreGirdDynamicPipe, typeof CoreServerGridComponent, typeof CoreGridColumnTemplateComponent, typeof CoreGridFiltersComponent, typeof CoreGridFilterTemplateComponent, typeof CoreGridDialogFilterComponent, typeof CoreGridConfigUserColumnDialogWindow, typeof CoreUserViewDialogWindow, typeof CoreGridExportModeDialogWindow, typeof CoreFilterOrganizationComponent, typeof CoreFilterOrganizationInternalComponent, typeof DoubleScrollbarsComponent, typeof CoreGridAlignButtonsComponent], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreControlModule, typeof CoreDialogModule, typeof CoreOrganizationModule], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreGirdDynamicPipe, typeof CoreServerGridComponent, typeof CoreGridAlignButtonsComponent, typeof CoreFilterOrganizationComponent, typeof CoreFilterOrganizationInternalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreGridModule>;
}

interface IGridSaveUserState {
    userId?: number;
    viewKey: string;
    viewTitle?: string;
    pageSize?: number;
    filters?: IFilterItem[];
    variativeViewMode?: ViewMode;
    callback?: Function;
}

interface IOrderedObject {
    order: number;
}
declare class CoreGridUtility {
    static order(a: any, b: any): number;
}

interface MultiActions {
    data?: any;
    runCallback?: Function;
    progressCallback?: Function;
    doneCollback?: Function;
}
declare abstract class LongTastService {
    _makeOptions(url: string, actions: MultiActions): IMethodOptions;
}

interface IStepsSegment {
    index: number;
    description: string;
    isAdditional: boolean;
    enabled: boolean;
}

declare class StepperEnabledPipe implements PipeTransform {
    transform(items: IStepsSegment[]): IStepsSegment[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperEnabledPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StepperEnabledPipe, "stepperEnabled", false>;
}

declare class CoreStepperComponent {
    private _pipe;
    steps: IStepsSegment[];
    form: NgForm;
    directFill: boolean;
    hideButtons: boolean;
    hideFooter: boolean;
    stepperDone: EventEmitter<any>;
    step: number;
    get active(): IStepsSegment[];
    get lastIndex(): number;
    constructor(_pipe: StepperEnabledPipe);
    goToStep(index: number): void;
    back(): void;
    next(): void;
    accept(): void;
    private getActive;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreStepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreStepperComponent, "core-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "form": { "alias": "form"; "required": false; }; "directFill": { "alias": "directFill"; "required": false; }; "hideButtons": { "alias": "hideButtons"; "required": false; }; "hideFooter": { "alias": "hideFooter"; "required": false; }; }, { "stepperDone": "stepperDone"; }, never, ["*"], false, never>;
}

declare class StepperAdditionalPipe implements PipeTransform {
    transform(items: IStepsSegment[]): IStepsSegment[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperAdditionalPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StepperAdditionalPipe, "stepperAdditional", false>;
}

declare class CoreStepperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreStepperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreStepperModule, [typeof CoreStepperComponent, typeof StepperAdditionalPipe, typeof StepperEnabledPipe], [typeof CoreBaseModule, typeof CoreMatModule], [typeof CoreStepperComponent, typeof StepperAdditionalPipe, typeof StepperEnabledPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreStepperModule>;
}

declare class SortLinksPipe implements PipeTransform {
    transform(value: IOrganizationLink[]): IOrganizationLink[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SortLinksPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SortLinksPipe, "sortLinks", false>;
}

interface IUserSettingsDto {
    userId: number;
    organizationId: number;
    key: string;
    value: any;
}
declare class UserAdditionalSettingsDto implements IUserSettingsDto {
    static MENU_SETTINGS_KEY: string;
    static USER_WIDGET_SETTINGS_KEY: string;
    userId: number;
    organizationId: number;
    key: string;
    value: any;
    constructor(userId: number, organizationId: number, value: any, key: string);
}
declare class UserMenuSettings {
    isCollapse: boolean;
    isFull: boolean;
    isViewTooltips: boolean;
    items: UserMenuSettingsItem[];
    constructor();
}
declare class UserMenuSettingsItem {
    id: string;
    hidden: boolean;
    expanded: boolean;
}

declare class CoreUserSettingsService {
    _startUp: Startup;
    _ajaxM: AjaxService;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    removeUserSettings(key: string, subKey: string): Observable<IResponse>;
    setUserSettings(userSettings: IUserSettingsDto): Observable<IResponse>;
    getUserSettings(userId: number, organizationId: number, key: string): Observable<IEntityResponse>;
    setAdditionalUserSettings(userSettings: UserAdditionalSettingsDto): Observable<any>;
    setWidgetUserSettings(userSettings: UserAdditionalSettingsDto, addIfNotExists?: boolean): Observable<any>;
    private removePropFromObject;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreUserSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreUserSettingsService>;
}

declare class CorePageTooltipVirtualAccountComponent extends CoreAbstractComponent implements OnInit {
    data: any;
    VA: VirtualAccount;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CorePageTooltipVirtualAccountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CorePageTooltipVirtualAccountComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CorePage extends CoreBaseDestroyComponent implements OnInit {
    private _injector;
    private _contextService;
    private _router;
    private _popup;
    private _userSettingSrv;
    private _pageService;
    private _startM;
    virtualAccountTooltipComponentType: Type<CorePageTooltipVirtualAccountComponent>;
    menuAccordeon: QueryList<MatAccordion>;
    selectedItem: any;
    private _storage;
    private _authService;
    private _menuItems;
    diag: DiagInfo;
    menuSettings: UserMenuSettings;
    hoverMenu: boolean;
    menuHeight: number;
    VM: VisualSettingManager;
    isShowSupportInfo: boolean;
    get menuItems(): MenuItem[];
    handleSubMenuItem(subMenuItems: MenuItem[]): MenuItem[];
    get session(): UserSessionData;
    get haveMessageChat(): boolean;
    get userCardUrl(): string;
    get organizationCardUrl(): string;
    get accountCardUrl(): string;
    get notificationSubsCardUrl(): string;
    get organizationLinks(): IOrganizationLink[];
    get showNewBtn(): boolean;
    constructor(_injector: Injector, _contextService: ContextService, _router: Router, _popup: PopupResults, _userSettingSrv: CoreUserSettingsService, _pageService: PageService, _startM: Startup);
    ngOnInit(): void;
    initAdditionaSettings(callback: Function): void;
    showSupportInfo(): void;
    getMaxMenuHeight(): Object;
    onOpenedMenuPanel(item: MenuItem): void;
    onClosedMenuPanel(item: MenuItem): void;
    onMenuItemSettingsUpdated(settings: UserMenuSettings): void;
    private _makeExpandedSetting;
    toggleNavBar(): void;
    toggleFullMenu(): void;
    editMenu(): void;
    private _updateMenuSettings;
    menuMouseLeave(): void;
    private _selectedMenuItemLogic;
    chengeCurrentLink(linkId: number): void;
    trimOrganizationName(detail: IOrganizationLinkItem): string;
    openChat(): void;
    logout(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CorePage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CorePage, "core-page", never, {}, {}, never, ["[pageHead]", "[pageBody]"], false, never>;
}

declare class CorePageTitleComponent extends CoreTitlePage {
    static ɵfac: i0.ɵɵFactoryDeclaration<CorePageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CorePageTitleComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreErrorPage extends CoreAbstractComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreErrorPage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreErrorPage, "core-error", never, {}, {}, never, never, false, never>;
}

declare class CoreForbiddenPage extends CoreAbstractComponent {
    VM: VisualSettingManager;
    constructor(injector: Injector);
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreForbiddenPage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreForbiddenPage, "core-forbidden", never, {}, {}, never, never, false, never>;
}

declare class CoreNotFoundPage extends CoreAbstractComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreNotFoundPage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreNotFoundPage, "core-notfound", never, {}, {}, never, never, false, never>;
}

declare class CorePageContentComponent extends CoreAbstractComponent {
    headHeight: number;
    titleHeight: number;
    footerHeight: number;
    hideChat: boolean;
    rightPanel: boolean;
    leftfPanel: boolean;
    contentHeight: number;
    constructor(_ngZone: NgZone);
    getMaxContentHeight(): Object;
    getColSize(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CorePageContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CorePageContentComponent, "core-page-content", never, { "headHeight": { "alias": "headHeight"; "required": false; }; "titleHeight": { "alias": "titleHeight"; "required": false; }; "footerHeight": { "alias": "footerHeight"; "required": false; }; "hideChat": { "alias": "hideChat"; "required": false; }; "rightPanel": { "alias": "rightPanel"; "required": false; }; "leftfPanel": { "alias": "leftfPanel"; "required": false; }; }, {}, never, ["[pageContentLeft]", "[pageContentBody]", "[pageContentRight]"], false, never>;
}

declare class MiniDraftItem {
    systemObjectId: number;
    customerInn?: string;
    customerKpp?: string;
    module: string;
    templateData: any;
}

declare class MiniDraftService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    customerLink(draft: MiniDraftItem): Observable<IEntityResponse>;
    saveMiniDraft(draft: MiniDraftItem): Observable<IEntityResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MiniDraftService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MiniDraftService>;
}

interface NewRequestParams extends IFederationEntity {
    systemObjectId: number;
    isBrokerSide: boolean;
    mode: number;
}
declare class CoreMiniDraftDialogWindow extends CoreBaseDestroyComponent implements AfterViewInit {
    private _dialogRef;
    data: NewRequestParams;
    private _service;
    private _router;
    private _popupResults;
    private _startup;
    private _cookieService;
    private _notificationSrv;
    productTemplate: ViewContainerRef;
    organizationSearch: CoreOrganizationSearchComponent;
    systemObjectId: number;
    item: MiniDraftItem;
    hidden: boolean;
    current: IOrganizationLink;
    get session(): UserSessionData;
    constructor(_dialogRef: MatDialogRef<CoreMiniDraftDialogWindow>, data: NewRequestParams, _service: MiniDraftService, _router: Router, _popupResults: PopupResults, _startup: Startup, _cookieService: BrowserLocalStorage, _notificationSrv: CoreNotificationService);
    getContainer(): ViewContainerRef;
    ngAfterViewInit(): Promise<void>;
    loadExternalWidget(): Promise<void>;
    onDataChange($event: any): void;
    onSearchClick(data: OrganizationSearchResult): void;
    save($event: any): void;
    private createMiniDraftObject;
    private navigateToUrl;
    private handleResponse;
    private handleCustomerLink;
    private handleSaveMiniDraft;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreMiniDraftDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreMiniDraftDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

interface MenuSettingDialogOptions {
    items: MenuItem[];
    settings: UserMenuSettings;
}
declare class CoreMenuSettingDialogWindow extends CoreBaseDestroyComponent {
    private _dialogRef;
    data: MenuSettingDialogOptions;
    constructor(_dialogRef: MatDialogRef<CoreMenuSettingDialogWindow>, data: MenuSettingDialogOptions);
    isSelectedRow(item: MenuItem): boolean;
    getCheckboxName(item: MenuItem, index: number, level: number): string;
    onSelectedChange(event: boolean, item: MenuItem, parent: MenuItem | null): void;
    private addAllSubItems;
    private shouldUpdateParent;
    private addAllParents;
    private syncParentsState;
    private syncParentStateRecursive;
    private findParentMenuItem;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreMenuSettingDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreMenuSettingDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreRigthMenuComponent extends CoreBaseDestroyComponent {
    private _injector;
    private cdRef;
    menuItems: MenuItem[];
    menuSettings: UserMenuSettings;
    showNewBtn: boolean;
    menuItemExpanded: EventEmitter<MenuItem>;
    menuItemCollapsed: EventEmitter<MenuItem>;
    menuItemSettingsUpdated: EventEmitter<UserMenuSettings>;
    private _storage;
    constructor(_injector: Injector, cdRef: ChangeDetectorRef);
    isSelectedMenuItem(menuItem: any): boolean;
    onMenuItemClick(item: MenuItem): void;
    checkExpanded(item: MenuItem): boolean;
    onOpenedMenuPanel(item: MenuItem): void;
    onClosedMenuPanel(item: MenuItem): void;
    goToUrl(event: MouseEvent, item: MenuItem): void;
    private _makeExpandedSetting;
    handleSubMenuItem(subMenuItems: MenuItem[]): MenuItem[];
    createNew(event: MouseEvent, item: MenuItem): void;
    deleteMenuItem(event: MouseEvent, item: MenuItem): void;
    /**
     * Рекурсивно удаляет элемент меню из многоуровневой структуры
     * @param items Массив элементов меню для поиска
     * @param userViewName Имя представления для удаления
     * @returns true если элемент был найден и удален
     */
    private _removeMenuItemRecursive;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreRigthMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreRigthMenuComponent, "core-rigth-menu", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "menuSettings": { "alias": "menuSettings"; "required": false; }; "showNewBtn": { "alias": "showNewBtn"; "required": false; }; }, { "menuItemExpanded": "menuItemExpanded"; "menuItemCollapsed": "menuItemCollapsed"; "menuItemSettingsUpdated": "menuItemSettingsUpdated"; }, never, never, false, never>;
}

declare class Chat {
    id?: string;
    name: string;
    statusRow?: string;
    avatarColor?: string;
    avatarLink?: string;
    lastMessage?: string;
    lastMessageDate?: Date;
    config: IChatConfig;
    newMessage?: boolean;
    isPrivate: boolean;
    isProvider: boolean;
    chatUsers: IUserChat[];
    isOnline?: boolean;
}
declare class IChatConfig {
    isFavorite: boolean;
    mute: boolean;
}
interface IUserChat {
    id: string;
    userId: number;
    fullName?: string;
    avatarColor?: string;
    avatarLink?: string;
    isOnline?: boolean;
}
interface IProfileUserChat extends IUserChat {
    statusRow: string;
}
interface IAddUserIntoChat {
    roomId: string;
    usersIds: number[];
}
interface IChatOrganizations {
    roomId: string;
    requestId: string;
    clientOrganizationId: number;
    distributedOrganizationIds?: number[];
}

declare class CoreChatRoomComponent extends CoreAbstractComponent {
    overlay: Overlay;
    viewContainerRef: ViewContainerRef;
    chat: Chat;
    chatElement: HTMLElement;
    sub: Subscription;
    overlayRef: OverlayRef | null;
    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef);
    getChatFullName(name: string): string;
    getFirstStrongContent(text: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatRoomComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatRoomComponent, "core-chat-item", never, { "chat": { "alias": "chat"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum ParentMessageType {
    Answer = 0,
    Forward = 1
}

interface ISendMessage {
    content: string;
    onlyOrganizations?: boolean;
    parentMessageId?: Guid | string;
    parentMessageType?: ParentMessageType;
}

interface ISignalRMessage {
    id: Guid | string;
    userId: string;
    roomId: string;
    content: string;
    onlyOrganizations?: boolean;
    organizationId?: number;
    attachment?: any;
    parentMessageId?: Guid | string;
    parentMessageType?: ParentMessageType;
    cacheMessageId?: number;
}

declare class SignalRService extends SignalBaseService {
    private _start;
    isSending: boolean;
    private readonly STORAGE_KEY;
    private _pendingMessagesSubject;
    pendingMessages$: rxjs.Observable<ISignalRMessage[]>;
    constructor(_start: Startup);
    private loadFromStorage;
    private saveToStorage;
    addPendingMessage(message: ISignalRMessage): void;
    confirmMessageSent(message: ISignalRMessage): void;
    getHubUrl(userId: any): string;
    onReconnected(): Function;
    onReconnectedLogic(): Function;
    onReceived(): Function;
    onSent(): Function;
    onSentFail(): Function;
    onCantSent(): Function;
    sendMessage(message: ISendMessage, from: any, groupId: any, fileData?: any): void;
    private _sendStorageMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalRService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalRService>;
}

interface ICreateRoomDto {
    name: string;
    userIds: string[];
}

declare class SellanChatUsersService {
    private _ajaxM;
    private _startUpM;
    private _extendNotif;
    chatUser: IProfileUserChat;
    isReady: ReplaySubject<any>;
    reloadUsersList: ReplaySubject<any>;
    chatUserHaveNewMessage: boolean;
    private users;
    userSelected: EventEmitter<Chat>;
    constructor(_ajaxM: AjaxService, _startUpM: Startup, _extendNotif: PageService);
    getChatUserInfo(): Observable<IEntityResponse>;
    updateChetUserInfo(profile: IProfileUserChat): Observable<any>;
    createUserRoom(dto: ICreateRoomDto): Observable<any>;
    getUserChats(): Observable<any>;
    addUserIntoGroup(dto: any): Observable<any>;
    removeUserFromGroup(dto: any): Observable<any>;
    getChats(tabIndex: number): Array<Chat>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatUsersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SellanChatUsersService>;
}

declare class SellanChatNotificationService {
    private _signalRService;
    private _chatUserService;
    isNotify: ReplaySubject<any>;
    constructor(_signalRService: SignalRService, _chatUserService: SellanChatUsersService);
    startChatConnection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SellanChatNotificationService>;
}

declare class CoreChatWidgetBalloonsComponent extends CoreBaseDestroyComponent implements OnInit {
    private usersService;
    private _notificationService;
    private _drawer;
    private _cd;
    private _extendNotif;
    private _сoreUserSettingsService;
    private _maxDialogCount;
    bottom: ElementRef;
    botName: string;
    botAvatar: string;
    userAvatar: string;
    opened: boolean;
    hide: boolean;
    hideUsers: boolean;
    private addSettingKey;
    _visible: boolean;
    private lastSavedHideUsers;
    rooms: Chat[];
    constructor(usersService: SellanChatUsersService, _notificationService: SellanChatNotificationService, _drawer: DrawerService, _cd: ChangeDetectorRef, _extendNotif: PageService, _сoreUserSettingsService: CoreUserSettingsService);
    get visible(): boolean;
    set visible(visible: boolean);
    focus: Subject<unknown>;
    scrollToBottom(): void;
    ngOnInit(): void;
    openChat(chat: Chat): void;
    hideUsersChat(): void;
    saveState(): void;
    private _getCachedHideUsers;
    private _cacheHideUsers;
    private _loadRooms;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatWidgetBalloonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatWidgetBalloonsComponent, "core-widget-balloons", never, { "botName": { "alias": "botName"; "required": false; }; "botAvatar": { "alias": "botAvatar"; "required": false; }; "userAvatar": { "alias": "userAvatar"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreChatService {
    private _ajaxM;
    private _startUpM;
    constructor(_ajaxM: AjaxService, _startUpM: Startup);
    getRooms(filter?: string): Observable<any>;
    getMyRooms(pageIndex?: number, filter?: string): Observable<any>;
    getUsers(filter?: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreChatService>;
}

declare class CoreChatListDrawerComponent extends CoreBaseDestroyComponent implements OnInit, OnDestroy {
    config: any;
    private _drawer;
    private _service;
    private _popup;
    name: string;
    selectedRoom: Chat;
    blockLoading: boolean;
    roomSearch: string;
    roomsPage: number;
    rooms: Chat[];
    get showEmptySearch(): boolean;
    private _eventListener;
    private _callDialogListner;
    constructor(_eventBroker: EventBrokerService, config: any, _drawer: DrawerService, _service: CoreChatService, _popup: PopupResults);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSearchChange($event: any): void;
    onScroll($event: any): void;
    userSelected(chat: Chat): void;
    newChat(): void;
    closeDrawChat(): void;
    private _reloadChat;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatListDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatListDrawerComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreChatListMenuComponent extends CoreBaseDestroyComponent {
    private _drawer;
    private _service;
    constructor(_drawer: DrawerService, _service: SellanChatUsersService);
    newChat(): void;
    myProfile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatListMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatListMenuComponent, "core-chat-list-menu", never, {}, {}, never, never, false, never>;
}

declare class CoreChatDialodReadingMessageTooltipComponent extends CoreAbstractComponent implements OnInit {
    users: IUserChat[];
    data: any;
    ngOnInit(): void;
    parseData({ users }: {
        users: any;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatDialodReadingMessageTooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatDialodReadingMessageTooltipComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CertificateListComponent extends CoreAbstractComponent implements OnInit {
    doubleClick: EventEmitter<any>;
    _cryptoProvider: any;
    _selection: SelectionModel<ICertificate>;
    _dataSourceClient: ICertificate[];
    showCertificates: boolean;
    loaded: boolean;
    filterText: string;
    isShowSearch: boolean;
    set input(element: ElementRef<HTMLInputElement>);
    constructor();
    ngOnInit(): void;
    simpleClickEmit(row: ICertificate): void;
    doubleClickEmit(row: ICertificate): void;
    checkInput(): void;
    clearInput(): void;
    private sortBySubject;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CertificateListComponent, "core-certificate-sign-list", never, {}, { "doubleClick": "doubleClick"; }, never, never, false, never>;
}

declare class AttorneyService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    check(thumbprint: string): Observable<any>;
    load(fileId: string, isMachineReadable: boolean, model?: any): Observable<any>;
    needAttorney(cert: ICertificate): Observable<any>;
    uploadFromFns(query: string): Observable<any>;
    getInfo(id: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttorneyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttorneyService>;
}

declare class CertificateListWindow extends CoreAbstractComponent implements AfterViewInit {
    private dialogRef;
    private _attorneyService;
    private _notification;
    private _dialog;
    private _cd;
    data: any;
    get showButtonCertificates(): boolean;
    showCertificateTitle(): "Выбор сертификата" | "СЕРТИФИКАТ КЭП НЕ НАЙДЕН";
    certificateSignListControl: CertificateListComponent;
    constructor(dialogRef: MatDialogRef<CertificateListWindow>, _attorneyService: AttorneyService, _notification: CoreNotificationService, _dialog: MatDialog, _cd: ChangeDetectorRef, data: any);
    ngAfterViewInit(): void;
    showSearch($event: any): void;
    sign($event?: ICertificate): void;
    sendContactSupport(): void;
    private _checkAttorney;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateListWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CertificateListWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

interface IContactSupportItem {
    name: string;
    phone: string;
}

type ResultSingFunction = (sing: CryptoSignature, cert: Certificate) => void;
type ResultSingArrayFunction = (sing: CryptoSignature[]) => void;
interface SignFileData {
    fileId: string;
    multiOrganizationId?: number;
}
declare class CryptoSignService {
    private _startUp;
    private _dialog;
    private _ajaxM;
    constructor(_startUp: Startup, _dialog: MatDialog, _ajaxM: AjaxService);
    verification(verificationCallback: ResultSingFunction, isLogin?: boolean, useOnlyDirector?: boolean): void;
    private _verificationSingProcess;
    signFiles(filesData: SignFileData[], needVersion: boolean, signCallback?: ResultSingArrayFunction, cancellationCallback?: Function, organizationId?: number, allowOnlyCeo?: boolean, certificate?: Certificate): void;
    private _signFiles;
    private _signFilesSingProcess;
    private _openWindow;
    private _encodeBase64;
    loadFileSignatures(fileId: string): Observable<any>;
    saveAuthFile(upload: any): Observable<any>;
    addAuthFile(signId: string, fileId: string): Observable<any>;
    getSignerIpCountry(ip: string): Observable<IEntityResponse>;
    sendContactSupport(item: IContactSupportItem): Observable<IResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoSignService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoSignService>;
}

declare class SupportDialogWindow extends CoreBaseDestroyComponent {
    private _dialogRef;
    private _popup;
    private _service;
    item: IContactSupportItem;
    constructor(_dialogRef: MatDialogRef<SupportDialogWindow>, _popup: PopupResults, _service: CryptoSignService);
    send(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SupportDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SupportDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFileSignaturesComponent extends CoreBaseDestroyComponent implements OnInit {
    private _dialog;
    private _ajaxM;
    private _cryptoSignM;
    private _popupM;
    fileId: string;
    newCurrent: EventEmitter<ISignatureInfo>;
    uploadConfig: UploaderConfig;
    current: ISignatureInfo;
    signatures: ISignatureInfo[];
    authority: string;
    constructor(_dialog: MatDialog, _ajaxM: AjaxService, _cryptoSignM: CryptoSignService, _popupM: PopupResults);
    ngOnInit(): void;
    download(url: string): void;
    viewSignature(selected: ISignatureInfo): void;
    uploadAuthFile(e: any): void;
    showCountryAlert(countryCode?: string): boolean;
    private initAuthority;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileSignaturesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFileSignaturesComponent, "core-file-signatures", never, { "fileId": { "alias": "fileId"; "required": false; }; }, { "newCurrent": "newCurrent"; }, never, never, false, never>;
}

declare class FilterCertPipe implements PipeTransform {
    transform(certificates: ICertificate[], filter: string): ICertificate[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCertPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterCertPipe, "filterCert", false>;
}

declare class CoreAttorneyUploadWindow extends CoreBaseDestroyComponent implements OnInit {
    dialogRef: MatDialogRef<CoreAttorneyUploadWindow>;
    data: any;
    private _startUp;
    private _service;
    dialog: MatDialog;
    private _popupResults;
    constructor(dialogRef: MatDialogRef<CoreAttorneyUploadWindow>, data: any, _startUp: Startup, _service: AttorneyService, dialog: MatDialog, _popupResults: PopupResults);
    fileConfig: UploaderConfig;
    signatureConfig: UploaderConfig;
    isAttorneyLoaded: boolean;
    files: UploadedFile[];
    organizationInn: string;
    personInn: string;
    attorneyId: string;
    ngOnInit(): void;
    upload(): void;
    getFromFns(): void;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAttorneyUploadWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAttorneyUploadWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFileUploaderComponent extends CoreBaseDestroyComponent implements ControlValueAccessor, Validator, OnInit, AfterViewInit {
    private _startUp;
    private _ajaxM;
    private _popupM;
    private _context;
    hideAttributes: boolean;
    hideLoading: boolean;
    loadedDocument: boolean;
    dataSource: UploadedFile[];
    config: UploaderConfig;
    needUpload: boolean;
    elementId: string;
    anonymAccessItemId: string;
    private _uploadInput;
    valueChange: EventEmitter<any>;
    autogenerateClick: EventEmitter<any>;
    filesLoaded: EventEmitter<any>;
    get value(): any;
    set value(v: any);
    get isRequiredSign(): boolean;
    constructor(_startUp: Startup, _ajaxM: AjaxService, _popupM: PopupResults, _context: ContextService);
    itCanViewed(val: UploadedFile): boolean;
    onTouched: Function;
    onChange: Function;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onChangeInput(e: any, config?: UploaderConfig): void;
    onChangeSignature(e: any, config?: UploaderConfig, item?: UploadedFile): void;
    uploadFromArchive(): void;
    loadExternal(): void;
    generageDocument(): void;
    addRows(items: UploadedFile[]): void;
    viewAction(row: UploadedFile): void;
    download(row: UploadedFile, parameters?: string): void;
    signaturesAction(row: UploadedFile): void;
    attributeAction(row: UploadedFile): void;
    removeAction(item: UploadedFile, emitValueChange?: boolean): void;
    clearAction(emitValueChange?: boolean): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    filesDropped(files: FileHandle[]): void;
    private _handleFiles;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileUploaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFileUploaderComponent, "core-file-uploader", never, { "config": { "alias": "config"; "required": false; }; "needUpload": { "alias": "needUpload"; "required": false; }; "elementId": { "alias": "elementId"; "required": false; }; "anonymAccessItemId": { "alias": "anonymAccessItemId"; "required": false; }; }, { "valueChange": "valueChange"; "autogenerateClick": "autogenerateClick"; "filesLoaded": "filesLoaded"; }, never, never, false, never>;
}

interface IFilePreviewOptions {
    fileType: FileTypeEnum;
    previewTitle: string;
    previewText: string;
    files: UploadedFile[];
    callback: Function;
    metadata?: any;
    anonymAccessItemId: string;
}
declare class CoreFilePreviewDialogWindow extends CoreAbstractComponent implements OnInit {
    item: IFilePreviewOptions;
    filesConfig: UploaderConfig;
    constructor(_dialogRef: MatDialogRef<CoreFilePreviewDialogWindow>, item: IFilePreviewOptions);
    ngOnInit(): void;
    accept($event: any): void;
    private _iniPrintFormUploader;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFilePreviewDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFilePreviewDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

interface DocumentViewerModel {
    data: any;
    isConvert: boolean;
    fileExtension: string;
}

declare class FileViewerDialogWindow extends CoreAbstractComponent implements OnInit {
    dialogRef: MatDialogRef<FileViewerDialogWindow>;
    model: DocumentViewerModel;
    get extensionCond(): boolean;
    private url;
    constructor(dialogRef: MatDialogRef<FileViewerDialogWindow>, model: DocumentViewerModel);
    ngOnInit(): void;
    getURL(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileViewerDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileViewerDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFileSignatureService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    loadFileSignatures(fileId: string): Observable<any>;
    saveAuthFile(upload: any): Observable<any>;
    addAuthFile(signId: string, fileId: string): Observable<any>;
    getSignerIpCountry(ip: string): Observable<IEntityResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileSignatureService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreFileSignatureService>;
}

declare class AttroneyInfo {
    dateFrom: Date;
    dateTo: Date;
    number: string;
    representatives: string[];
    principalInn: string;
    powers: IPower[];
    principal: IOrganizationInfo;
    persons: any;
}
interface IPower {
    code: string;
    name: string;
}
interface IOrganizationInfo {
    name: string;
    inn: string;
    kpp: string;
    ogrn: string;
    address: string;
    phone: string;
}

declare class CoreFileSignaturesWindow extends CoreBaseDestroyComponent implements OnInit {
    data: any;
    private _popupM;
    private _service;
    private _startUp;
    private _ajaxM;
    private _attorneyService;
    uploadConfig: UploaderConfig;
    current: ISignatureInfo;
    signatures: ISignatureInfo[];
    authority: string;
    fileId: string;
    downloadSignatureUrl: string;
    needUploadFile: boolean;
    attroneyInfo: AttroneyInfo;
    isPowersShown: boolean;
    atttorneys: any;
    constructor(data: any, _popupM: PopupResults, _service: CoreFileSignatureService, _startUp: Startup, _ajaxM: AjaxService, _attorneyService: AttorneyService);
    ngOnInit(): void;
    download(url: string): void;
    openFNSLink(): void;
    viewSignature(selected: ISignatureInfo): void;
    showCountryAlert(countryCode?: string): boolean;
    powersClick(): void;
    private loadAttorneyInfo;
    private initAuthority;
    getAttorneyInfo(): string;
    getDownloadAttorneyUrl(): string;
    getMaxContentHeight(): Object;
    get showAttorneyBlock(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileSignaturesWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFileSignaturesWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFileSignaturesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileSignaturesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreFileSignaturesModule, [typeof CoreFileSignaturesWindow], [typeof CoreMatModule, typeof CoreDialogModule, typeof CorePipeModule, typeof CoreBaseModule, typeof CoreDirectiveModule], [typeof CoreFileSignaturesWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreFileSignaturesModule>;
}

declare class CoreFileAttributesService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    loadFileAttributes(fileId: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileAttributesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreFileAttributesService>;
}

interface IFileAttribute {
    attributeCode: string;
    attributeType: string;
    value: string;
}

declare class CoreFileAttributesWindow extends CoreBaseDestroyComponent implements OnInit {
    data: any;
    private _service;
    private _popup;
    fileId: string;
    attributes: IFileAttribute[];
    constructor(data: any, _service: CoreFileAttributesService, _popup: PopupResults);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileAttributesWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFileAttributesWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFileAttributesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFileAttributesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreFileAttributesModule, [typeof CoreFileAttributesWindow], [typeof CoreMatModule, typeof CoreDialogModule, typeof CorePipeModule, typeof CoreBaseModule, typeof CorePipeModule], [typeof CoreFileAttributesWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreFileAttributesModule>;
}

declare class CoreUploaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreUploaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreUploaderModule, [typeof CoreFileUploaderComponent, typeof CoreFilePreviewDialogWindow, typeof FileViewerDialogWindow], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreDialogModule, typeof CorePipeModule, typeof CoreFileSignaturesModule, typeof CoreFileAttributesModule, typeof CoreDirectiveModule], [typeof CoreFileUploaderComponent, typeof CoreFilePreviewDialogWindow, typeof FileViewerDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreUploaderModule>;
}

declare class CoreAttorneyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAttorneyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreAttorneyModule, [typeof CoreAttorneyUploadWindow], [typeof CoreMatModule, typeof CoreDialogModule, typeof CorePipeModule, typeof CoreBaseModule, typeof CoreUploaderModule, typeof CoreControlModule], [typeof CoreAttorneyUploadWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreAttorneyModule>;
}

declare class CoreCryptoModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCryptoModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreCryptoModule, [typeof CertificateListComponent, typeof CertificateListWindow, typeof SupportDialogWindow, typeof CoreFileSignaturesComponent, typeof FilterCertPipe], [typeof CoreMatModule, typeof CoreDialogModule, typeof CorePipeModule, typeof CoreBaseModule, typeof CoreAttorneyModule, typeof CoreControlModule, typeof CoreNotificationModule, typeof CoreContactVerificationModule], [typeof CertificateListComponent, typeof CertificateListWindow, typeof SupportDialogWindow, typeof CoreFileSignaturesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreCryptoModule>;
}

declare enum MessageStatus {
    Send = 1,
    Read = 2,
    NotSend = 3
}
declare class Message {
    id: Guid;
    from: string;
    content: string;
    userId: string;
    roomId: string;
    isAttachment?: boolean;
    hasSignature?: boolean;
    status: MessageStatus;
    type: 'received' | 'sent';
    attachmentId?: string;
    parentMessageType: ParentMessageType;
    parentMessageId?: Guid | string;
    parentMessageContent?: string;
    parentMessageUserName?: string;
    timestamp: any;
    history: MessageHistory;
    cacheMessageId?: number;
    found?: boolean;
}
declare class MessageHistory {
    statusCode: number;
    users?: IUserChat[];
}

declare class SellanChatMessageService {
    private _startUpM;
    private _signalRService;
    private _chatUserService;
    private _ajaxM;
    private _notificationService;
    private messages;
    private roomId;
    private page;
    private pageSize;
    isLoading: boolean;
    messagesRanOut: boolean;
    storageMessages: any;
    userOrgId: number;
    constructor(_startUpM: Startup, _signalRService: SignalRService, _chatUserService: SellanChatUsersService, _ajaxM: AjaxService, _notificationService: SellanChatNotificationService);
    getMessages(): Message[];
    deleteMessageById(id: any): void;
    deleteMessageByCacheId(id: any): void;
    clearMessages(): void;
    updateRoomHistory(roomId: string): void;
    updatePageMessages(roomId: string): Observable<Message[]>;
    loadAllFoundMessages(searchMessagesIds: Array<Guid | string>): void;
    markMessageAsFound(searchMessagesIds: Array<Guid | string>, foundFlag: boolean): void;
    getRoomHistory(roomId: string): Observable<IEntityResponse>;
    markAttachmentBySign(fileId: string): Observable<any>;
    private addMessage;
    sendMessage(message: ISendMessage, roomId: any): void;
    forwardMessage(message: ISendMessage, roomId: any): void;
    sendAttachmentMessage(fileData: any, roomId: any): void;
    nextPage(): void;
    getPage(): number;
    getPageSize(): number;
    resetPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SellanChatMessageService>;
}

declare class CoreChatAbstractComponent extends CoreAbstractComponent implements OnInit {
    _dialog: MatDialog;
    _cryptoM: CryptoSignService;
    _popupM: PopupResults;
    chatMessageService: SellanChatMessageService;
    _startUpM: Startup;
    _ajaxM: AjaxService;
    chat: Chat;
    uploadConfig: UploaderConfig;
    constructor(_dialog: MatDialog, _cryptoM: CryptoSignService, _popupM: PopupResults, chatMessageService: SellanChatMessageService, _startUpM: Startup, _ajaxM: AjaxService);
    ngOnInit(): void;
    signFile(fileId: any): void;
    showSignFile(fileId: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatAbstractComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatAbstractComponent, "ng-component", never, { "chat": { "alias": "chat"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SellanChatSearchMessagesService {
    private _startUpM;
    private _ajaxM;
    private _messageService;
    searchMessagesId: Array<Guid>;
    messages: Array<Message>;
    constructor(_startUpM: Startup, _ajaxM: AjaxService, _messageService: SellanChatMessageService);
    getSearchMessagesResult(searchText: string, roomId: number): Observable<IEntityResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatSearchMessagesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SellanChatSearchMessagesService>;
}

declare class SellanChatSearchMessageComponent extends CoreAbstractComponent implements OnInit {
    private _searchService;
    private _messageService;
    roomId: number;
    message: ElementRef;
    searchMessagesIds: Array<Guid | string>;
    messages: Array<Message>;
    indexOfFound: number;
    countOfFound: number;
    searching: boolean;
    searchText: string;
    showSearchBar: boolean;
    private lastScrolledMessageId;
    buttonText: string;
    disabled: boolean;
    focus: EventEmitter<any>;
    send: EventEmitter<any>;
    dismiss: EventEmitter<any>;
    searchGoTo: EventEmitter<any>;
    constructor(_searchService: SellanChatSearchMessagesService, _messageService: SellanChatMessageService);
    ngOnInit(): void;
    focusMessage(): void;
    getSearchText(): any;
    resetSearch(): void;
    clearMessage(): void;
    searchMessage(): void;
    private expandAndCount;
    private escapeRegex;
    findNext(): void;
    findPrevious(): void;
    scrollToMessage(): void;
    getShowingStyle(): any;
    setShowSearchBar(event: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatSearchMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SellanChatSearchMessageComponent, "core-search-message", never, { "roomId": { "alias": "roomId"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "focus": { "alias": "focus"; "required": false; }; }, { "send": "send"; "dismiss": "dismiss"; "searchGoTo": "searchGoTo"; }, never, never, false, never>;
}

declare class SellanChatHighlighterPipe implements PipeTransform {
    transform(value: any, args: any, type: string, currentIndex?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatHighlighterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SellanChatHighlighterPipe, "highlighter", false>;
}

declare class CoreChatDialogDrawerComponent extends CoreChatAbstractComponent implements OnInit, DoCheck {
    config: any;
    private _drawer;
    signalRService: SignalRService;
    private _notificationService;
    overlay: Overlay;
    viewContainerRef: ViewContainerRef;
    _startUpM: Startup;
    _ajaxM: AjaxService;
    private highlighterPipe;
    private _appRef;
    private _injector;
    name: string;
    answerMsg?: Guid | string;
    answerMsgContent: string;
    goto: number;
    search: boolean;
    searchMessage: SellanChatSearchMessageComponent;
    messageBox: ElementRef;
    bottom: ElementRef;
    avatar: string;
    userAvatar: string;
    startingMessage: string;
    get footerHeight(): number;
    roomId: string;
    focus: Subject<unknown>;
    messages: Array<Message>;
    overlayRef: OverlayRef | null;
    tooltipWhoReadComponentType: Type<CoreChatDialodReadingMessageTooltipComponent>;
    private _menuComponentRef?;
    private _menuHostElement?;
    constructor(config: any, _drawer: DrawerService, signalRService: SignalRService, _dialog: MatDialog, _cryptoM: CryptoSignService, _popupM: PopupResults, _notificationService: SellanChatNotificationService, chatMessageService: SellanChatMessageService, overlay: Overlay, viewContainerRef: ViewContainerRef, _startUpM: Startup, _ajaxM: AjaxService, highlighterPipe: SellanChatHighlighterPipe, _appRef: ApplicationRef, _injector: Injector);
    handleKeyboardEvent(event: KeyboardEvent): void;
    onSearchShow($event: any): void;
    ngOnInit(): void;
    ngDoCheck(): void;
    private _refreshMessages;
    sendMessage(event: any): void;
    dateEquals(date1: any, date2: any): boolean;
    clearAnswerMessage(): void;
    closeDrawChat(): void;
    open({ x, y }: MouseEvent, message: any, chatMessage: any): void;
    close(): void;
    closeChat(event: boolean): void;
    scrollToBottom(): void;
    focusMessage(): void;
    onScroll($event: any): void;
    onGoto($event: any): void;
    setChat(event: any): void;
    goToChatList(): void;
    getHighlightedMessageContent(message: Message): string;
    getMatchIndex(messageId: string): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatDialogDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatDialogDrawerComponent, "ng-component", never, { "avatar": { "alias": "avatar"; "required": false; }; "userAvatar": { "alias": "userAvatar"; "required": false; }; "startingMessage": { "alias": "startingMessage"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreChatDialogMenuComponent extends CoreBaseDestroyComponent {
    private _drawer;
    private _chatUserService;
    private _popup;
    private _chatMessageService;
    chat: Chat;
    chatChanged: EventEmitter<Chat>;
    showSearch: EventEmitter<boolean>;
    searchState: boolean;
    constructor(_drawer: DrawerService, _chatUserService: SellanChatUsersService, _popup: PopupResults, _chatMessageService: SellanChatMessageService);
    search(): void;
    users(): void;
    close(): void;
    exit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatDialogMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatDialogMenuComponent, "core-chat-dialog-menu", never, { "chat": { "alias": "chat"; "required": false; }; }, { "chatChanged": "chatChanged"; "showSearch": "showSearch"; }, never, never, false, never>;
}

declare enum DeleteStatus {
    NotDeleted = 0,
    DeletedForAuthor = 1,
    DeletedForEveryone = 2
}

interface IDeleteChatMessageDto {
    roomId: string;
    messageId: string;
    deleteFlag: DeleteStatus;
}

declare class SellanChatMsgManagerService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    deleteMessage(dto: IDeleteChatMessageDto): Observable<any>;
    answerMessage(dto: IDeleteChatMessageDto): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatMsgManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SellanChatMsgManagerService>;
}

declare class CoreChatMessageMenuComponent extends CoreBaseDestroyComponent implements OnDestroy {
    private _msgSrv;
    private _usersSrv;
    private _drawer;
    private _signalRService;
    chat: Chat;
    message: Message;
    userMenu: TemplateRef<any>;
    messageAnswerEvent: EventEmitter<any>;
    messageDeleteEvent: EventEmitter<Guid>;
    messageStorageDeleteEvent: EventEmitter<number>;
    answerPersonallyEvent: EventEmitter<Chat>;
    messageForwardEvent: EventEmitter<number>;
    private _eventListener;
    constructor(_eventBroker: EventBrokerService, _msgSrv: SellanChatMsgManagerService, _usersSrv: SellanChatUsersService, _drawer: DrawerService, _signalRService: SignalRService);
    ngOnDestroy(): void;
    deleteMessage(deleteForAll: boolean): void;
    isPrivateRoom(): boolean;
    isSentMessage(): boolean;
    answer(): void;
    answerPersonally(): void;
    forwardMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatMessageMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatMessageMenuComponent, "core-chat-message-menu", never, { "chat": { "alias": "chat"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, { "messageAnswerEvent": "messageAnswerEvent"; "messageDeleteEvent": "messageDeleteEvent"; "messageStorageDeleteEvent": "messageStorageDeleteEvent"; "answerPersonallyEvent": "answerPersonallyEvent"; "messageForwardEvent": "messageForwardEvent"; }, never, never, false, never>;
}

interface INewRoomData {
    isNew: boolean;
    roomId?: number;
    chatName?: string;
    avatarColor?: string;
    avatarLink?: string;
    users?: IUserChat[];
}

declare class CoreChatNewDrawerComponent extends CoreBaseDestroyComponent implements OnInit {
    config: DrawerConfig<INewRoomData>;
    private _service;
    private _popup;
    private _eventBroker;
    private _drawer;
    private _chatUserService;
    name: string;
    added: IUserChat[];
    users: IUserChat[];
    userSearch: string;
    constructor(config: DrawerConfig<INewRoomData>, _service: CoreChatService, _popup: PopupResults, _eventBroker: EventBrokerService, _drawer: DrawerService, _chatUserService: SellanChatUsersService);
    ngOnInit(): void;
    onSelect($event: any, user: IUserChat): void;
    onSearchChange($event: any): void;
    close(): void;
    next(): void;
    private _reloadUsers;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatNewDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatNewDrawerComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreChatNewGroupDrawerComponent extends CoreBaseDestroyComponent {
    config: DrawerConfig<INewRoomData>;
    private _popup;
    private _drawer;
    private _chatUserService;
    private _eventBroker;
    private _avatarService;
    private _cropper;
    name: string;
    roomName: string;
    users: IUserChat[];
    constructor(config: DrawerConfig<INewRoomData>, _popup: PopupResults, _drawer: DrawerService, _chatUserService: SellanChatUsersService, _eventBroker: EventBrokerService, _avatarService: CoreAvatarService, _cropper: CoreCropperService);
    add(): void;
    close(): void;
    next(): void;
    uploadIcon(): void;
    removeIcon(): void;
    setColor(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatNewGroupDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatNewGroupDrawerComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreChatProfileDrawerComponent extends CoreBaseDestroyComponent {
    private _injector;
    config: DrawerConfig<IProfileUserChat>;
    private _popup;
    private _avatarService;
    private _cropper;
    private _drawer;
    private _chatUserService;
    private _context;
    myId: number;
    profile: IProfileUserChat;
    name: string;
    constructor(_injector: Injector, config: DrawerConfig<IProfileUserChat>, _popup: PopupResults, _avatarService: CoreAvatarService, _cropper: CoreCropperService, _drawer: DrawerService, _chatUserService: SellanChatUsersService, _context: ContextService);
    uploadIcon(): void;
    removeIcon(): void;
    setColor(): void;
    save(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatProfileDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatProfileDrawerComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreChatForwardDrawerComponent extends CoreBaseDestroyComponent implements OnInit {
    private _eventBroker;
    config: DrawerConfig<Message>;
    private _drawer;
    private _service;
    private _popup;
    private _chatMessageService;
    name: string;
    selectedRoom: Chat;
    blockLoading: boolean;
    roomSearch: string;
    roomsPage: number;
    rooms: Chat[];
    get showEmptySearch(): boolean;
    constructor(_eventBroker: EventBrokerService, config: DrawerConfig<Message>, _drawer: DrawerService, _service: CoreChatService, _popup: PopupResults, _chatMessageService: SellanChatMessageService);
    ngOnInit(): void;
    onSearchChange($event: any): void;
    onScroll($event: any): void;
    userSelected(chat: Chat): void;
    close(): void;
    private _reloadChat;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatForwardDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatForwardDrawerComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class SelectedChatUserFilterPipe implements PipeTransform {
    transform(items: IUserChat[], filters: IUserChat[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectedChatUserFilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SelectedChatUserFilterPipe, "selectedUsers", false>;
}

declare enum NewMsgMode {
    None = "None",
    Circle = "Circle",
    Border = "Border"
}
declare class CoreChatAvatarComponent extends CoreAbstractComponent {
    useInChat: boolean;
    url: string;
    backColor: string;
    fullName: string;
    newMsg: boolean;
    newMsgMode: NewMsgMode;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatAvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatAvatarComponent, "core-chat-avatar", never, { "useInChat": { "alias": "useInChat"; "required": false; }; "url": { "alias": "url"; "required": false; }; "backColor": { "alias": "backColor"; "required": false; }; "fullName": { "alias": "fullName"; "required": false; }; "newMsg": { "alias": "newMsg"; "required": false; }; "newMsgMode": { "alias": "newMsgMode"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreChatUserComponent extends CoreAbstractComponent {
    user: IUserChat;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreChatUserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreChatUserComponent, "core-chat-user", never, { "user": { "alias": "user"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SellanChatInputComponent extends CoreAbstractComponent implements OnInit {
    overlay: Overlay;
    viewContainerRef: ViewContainerRef;
    private _appRef;
    private _injector;
    buttonText: string;
    disabled: boolean;
    focus: EventEmitter<any>;
    send: EventEmitter<any>;
    dismiss: EventEmitter<any>;
    message: ElementRef;
    overlayRef: OverlayRef | null;
    private _menuComponentRef?;
    private _menuHostElement?;
    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, _appRef: ApplicationRef, _injector: Injector);
    ngOnInit(): void;
    focusMessage(): void;
    getMessage(): any;
    clearMessage(): void;
    open({ x, y }: MouseEvent, btn: any): void;
    close(): void;
    onSubmit(onlyOrganizations?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SellanChatInputComponent, "core-chat-input", never, { "buttonText": { "alias": "buttonText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "focus": { "alias": "focus"; "required": false; }; }, { "send": "send"; "dismiss": "dismiss"; }, never, never, false, never>;
}

declare class SellanChatSendMessageMenuComponent extends CoreBaseDestroyComponent {
    chat: Chat;
    message: Message;
    userMenu: TemplateRef<any>;
    messageConfrirmSentEvent: EventEmitter<any>;
    constructor();
    sendOrganizationMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatSendMessageMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SellanChatSendMessageMenuComponent, "core-chat-send-message-menu", never, { "chat": { "alias": "chat"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, { "messageConfrirmSentEvent": "messageConfrirmSentEvent"; }, never, never, false, never>;
}

declare class SellanChatCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanChatCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SellanChatCommonModule, [typeof SelectedChatUserFilterPipe, typeof CoreChatAvatarComponent, typeof CoreChatUserComponent, typeof SellanChatInputComponent, typeof SellanChatSendMessageMenuComponent, typeof SellanChatSearchMessageComponent, typeof SellanChatHighlighterPipe], [typeof CoreBaseModule, typeof CoreDialogModule, typeof CoreControlModule, typeof CoreMatModule], [typeof SelectedChatUserFilterPipe, typeof CoreChatAvatarComponent, typeof CoreChatUserComponent, typeof SellanChatInputComponent, typeof SellanChatSearchMessageComponent, typeof SellanChatHighlighterPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SellanChatCommonModule>;
}

declare class CoreTooltipContainerComponent extends CoreAbstractComponent implements AfterViewInit, AfterViewChecked {
    private _containerConfig;
    private _hostRect;
    private _containerRect;
    style: any;
    tooltipContainerClass: any;
    position: string;
    offset: number;
    coreTooltipContainerElementRef: ElementRef;
    constructor(_containerConfig: any);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    calculatePosition(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreTooltipContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreTooltipContainerComponent, "core-tooltip-container", never, { "position": { "alias": "position"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class CoreTooltipDirective implements OnDestroy {
    private _hostElement;
    private _injector;
    private _viewContainerRef;
    private _applicationRef;
    contentType: Type<any>;
    contentData: any;
    position: string;
    offset: number;
    hidden: boolean;
    private _coreTooltipContainerComponentRef;
    private _rootComponent;
    constructor(_hostElement: ElementRef, _injector: Injector, _viewContainerRef: ViewContainerRef, _applicationRef: ApplicationRef);
    ngOnDestroy(): void;
    mouseenter(): void;
    mouseout(): void;
    generateNgContent(): any[][];
    /**Gets the root view container to inject the component to */
    getRootViewContainer(): ComponentRef<any>;
    /**Gets the html element for a component ref. */
    getComponentRootNode(componentRef: ComponentRef<any>): HTMLElement;
    /**Gets the root component container html element. */
    getRootViewContainerNode(): HTMLElement;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreTooltipDirective, "[core-tooltip]", never, { "contentType": { "alias": "core-tooltip"; "required": false; }; "contentData": { "alias": "contentData"; "required": false; }; "position": { "alias": "position"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreTooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreTooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreTooltipModule, [typeof CoreTooltipContainerComponent, typeof CoreTooltipDirective], [typeof CoreBaseModule, typeof CoreMatModule], [typeof CoreTooltipContainerComponent, typeof CoreTooltipDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreTooltipModule>;
}

declare class SellanCoreChatModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SellanCoreChatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SellanCoreChatModule, [typeof CoreChatRoomComponent, typeof CoreChatWidgetBalloonsComponent, typeof CoreChatListDrawerComponent, typeof CoreChatListMenuComponent, typeof CoreChatDialodReadingMessageTooltipComponent, typeof CoreChatDialogDrawerComponent, typeof CoreChatDialogMenuComponent, typeof CoreChatMessageMenuComponent, typeof CoreChatNewDrawerComponent, typeof CoreChatNewGroupDrawerComponent, typeof CoreChatProfileDrawerComponent, typeof CoreChatForwardDrawerComponent], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreDialogModule, typeof CoreControlModule, typeof CoreUploaderModule, typeof SellanChatCommonModule, typeof CoreDrawerModule, typeof CoreCropperModule, typeof CoreTooltipModule], [typeof CoreChatRoomComponent, typeof CoreChatWidgetBalloonsComponent, typeof CoreChatListDrawerComponent, typeof CoreChatListMenuComponent, typeof CoreChatDialodReadingMessageTooltipComponent, typeof CoreChatDialogDrawerComponent, typeof CoreChatDialogMenuComponent, typeof CoreChatMessageMenuComponent, typeof CoreChatNewDrawerComponent, typeof CoreChatNewGroupDrawerComponent, typeof CoreChatProfileDrawerComponent, typeof CoreChatForwardDrawerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SellanCoreChatModule>;
}

declare class CoreLayoutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreLayoutModule, [typeof SortLinksPipe, typeof CorePage, typeof CorePageTitleComponent, typeof CoreErrorPage, typeof CoreForbiddenPage, typeof CoreNotFoundPage, typeof CorePageContentComponent, typeof CoreMiniDraftDialogWindow, typeof CorePageTooltipVirtualAccountComponent, typeof CoreMenuSettingDialogWindow, typeof CoreRigthMenuComponent], [typeof CorePipeModule, typeof CoreBaseModule, typeof SellanCoreChatModule, typeof CoreMatModule, typeof CoreControlModule, typeof CoreOrganizationModule, typeof CoreDialogModule, typeof CoreDrawerModule, typeof CoreTooltipModule, typeof CoreNotificationModule], [typeof CorePage, typeof CorePageTitleComponent, typeof CorePageContentComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreLayoutModule>;
}

declare class MenuService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getItems(module: string): Observable<IEntityResponse>;
    removeUserView(viewName: string): Observable<IResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
}

declare class AgentService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    saveAsAgent(organizationId: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AgentService>;
}

declare class CoreAddressCardComponent extends CoreAbstractComponent implements OnInit {
    readonly: boolean;
    item: IAddress;
    config: DadataConfig;
    valueChange: EventEmitter<any>;
    get isEmptyValue(): boolean;
    get isDisabled(): boolean;
    filteredDistrictTypes: Observable<ISimpleComboboxItem[]>;
    filteredLocalityTypes: Observable<ISimpleComboboxItem[]>;
    filteredStreetTypes: Observable<ISimpleComboboxItem[]>;
    filteredRoomTypes: Observable<ISimpleComboboxItem[]>;
    get districtTitle(): string;
    get localityTitle(): string;
    get streetTitle(): string;
    dadataConfig: DadataConfig;
    constructor();
    ngOnInit(): void;
    onAddressSelected(event: DadataSuggestion): void;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAddressCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAddressCardComponent, "core-address-card", never, { "readonly": { "alias": "readonly"; "required": false; }; "item": { "alias": "item"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class CoreFieldAddressComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit {
    private _dialog;
    private dadataConfig;
    get isImageEmpty(): boolean;
    constructor(_dialog: MatDialog);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    editValue(): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldAddressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldAddressComponent, "core-field-address", never, {}, {}, never, never, false, never>;
}

declare class IAddressDialogOptions {
    item: IAddress;
    readonlyMode: boolean;
    organizationId?: number;
    personId?: number;
    config?: DadataConfig;
}
declare class CoreAddressDialogWindow extends CoreAbstractComponent {
    dialogRef: MatDialogRef<CoreAddressDialogWindow>;
    data: IAddressDialogOptions;
    constructor(dialogRef: MatDialogRef<CoreAddressDialogWindow>, data: IAddressDialogOptions);
    save(): void;
    private _getFullAddress;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAddressDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAddressDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreAddressModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAddressModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreAddressModule, [typeof CoreAddressCardComponent, typeof CoreFieldAddressComponent, typeof CoreAddressDialogWindow], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreControlModule, typeof CoreDaDataModule, typeof CoreDialogModule, typeof CoreDirectiveModule], [typeof CoreFieldAddressComponent, typeof CoreAddressCardComponent, typeof CoreAddressDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreAddressModule>;
}

declare class AuthBlockedUserInstructionDialogWindow extends CoreAbstractComponent {
    data: string;
    showInstruction: boolean;
    constructor(data: string);
    viewInstruction(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthBlockedUserInstructionDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthBlockedUserInstructionDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

type MfaAskCodeRequest = {
    destination: string;
};
type MfaChallenge = {
    challenge: string;
};
type MfaAskCodeResponse = {
    displayPhone: string;
} & MfaChallenge;
type MfaConfirmRequest = {
    phone: string;
    enabled: boolean;
};

declare class TwoFactorService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    askAuthCode(request: MfaAskCodeRequest): Observable<any>;
    verifyAuthCode(challenge: string): Observable<any>;
    confirmTwoFactor(data: MfaConfirmRequest): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoFactorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwoFactorService>;
}

declare class MfaDialogWindow extends CoreBaseDestroyComponent implements OnInit {
    data: MfaAskCodeRequest;
    private _dialogRef;
    private _twoFactorService;
    private _popupResult;
    showCountDown: boolean;
    countDownTimeout: number;
    dialogTitleValue: string;
    displayPhone: string;
    private countDownInterval;
    private checkThreshold;
    private challenge;
    constructor(data: MfaAskCodeRequest, _dialogRef: MatDialogRef<MfaDialogWindow>, _twoFactorService: TwoFactorService, _popupResult: PopupResults);
    ngOnInit(): void;
    check(): void;
    private ask;
    private setTimeout;
    static ɵfac: i0.ɵɵFactoryDeclaration<MfaDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MfaDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreAuthModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAuthModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreAuthModule, [typeof AuthBlockedUserInstructionDialogWindow, typeof MfaDialogWindow], [typeof CoreMatModule, typeof CoreBaseModule, typeof CoreOrganizationModule, typeof CoreDialogModule, typeof CoreDirectiveModule, typeof CoreUploaderModule, typeof CoreCryptoModule, typeof CoreControlModule, typeof CorePipeModule, typeof i26$1.NgxMaskDirective, typeof i26$1.NgxMaskPipe, typeof CoreContactVerificationModule], [typeof AuthBlockedUserInstructionDialogWindow, typeof MfaDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreAuthModule>;
}

declare class CoreRouteDescription {
    static route500: {
        path: string;
        data: {
            title: string;
        };
        children: ({
            path: string;
            component: typeof CorePageTitleComponent;
            outlet: string;
        } | {
            path: string;
            component: typeof CoreErrorPage;
            outlet: string;
        })[];
    };
    static route403: {
        path: string;
        data: {
            title: string;
        };
        children: ({
            path: string;
            component: typeof CorePageTitleComponent;
            outlet: string;
        } | {
            path: string;
            component: typeof CoreForbiddenPage;
            outlet: string;
        })[];
    };
    static route404: {
        path: string;
        data: {
            title: string;
        };
        children: ({
            path: string;
            component: typeof CorePageTitleComponent;
            outlet: string;
        } | {
            path: string;
            component: typeof CoreNotFoundPage;
            outlet: string;
        })[];
    };
}

interface RecoveryPassword {
    userId?: number;
    userToken?: string;
    password: Password;
}
interface Password {
    password: string;
    confirm: string;
}

declare enum RegistrationType {
    PhysicalPerson = "PhysicalPerson",
    Juridical = "Juridical",
    Individual = "Individual"
}
declare enum RegistrationMethod {
    Password = "Password",
    Mobile = "Mobile",
    Signature = "Signature"
}
declare class RegistrationData {
    registrationMethod: string;
    registrationType: string;
    isBroker: boolean;
    attorneyId?: string;
    organizationId: number;
    organizationName: string;
    organizationShortName: string;
    inn: string;
    kpp?: string;
    ogrn: string;
    okopf?: ISimpleComboboxItem;
    juridicalAddress: string;
    address: any;
    firstName: string;
    middleName: string;
    lastName: string;
    phone: string;
    email: string;
    isCeo: boolean;
    password: Password;
    makeOrganizationCard: boolean;
    reglamentAgreement: boolean;
    personalDataAgreement: boolean;
    text: string;
    consent: boolean;
    constructor();
    cleenOrganizationData(): void;
}

declare class RegistrationService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    registrate(data: RegistrationData): Observable<any>;
    registrateDocument(data: RegistrationData): Observable<any>;
    registrateSignData(signature: string, attorneyId?: string): Observable<any>;
    recover(email: string): Observable<any>;
    changePassword(model: RecoveryPassword): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegistrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegistrationService>;
}

declare class SlnBaseAuthRecoveryDoneComponent extends CoreBasePage {
    _router: Router;
    _route: ActivatedRoute;
    _registrationService: RegistrationService;
    _popupResult: PopupResults;
    model: RecoveryPassword;
    constructor(injector: Injector, _router: Router, _route: ActivatedRoute, _registrationService: RegistrationService, _popupResult: PopupResults);
    changePassword(): void;
    _changePassword(token?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnBaseAuthRecoveryDoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnBaseAuthRecoveryDoneComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class SlnBaseAuthRecoveryComponent extends CoreBasePage {
    _registrationService: RegistrationService;
    email: string;
    done: boolean;
    errors: string;
    constructor(injector: Injector, _registrationService: RegistrationService);
    recoverPassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnBaseAuthRecoveryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnBaseAuthRecoveryComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class RegistrationDocumentService {
    private _dialog;
    private _service;
    private _cryptoM;
    private _popUp;
    constructor(_dialog: MatDialog, _service: RegistrationService, _cryptoM: CryptoSignService, _popUp: PopupResults);
    singRegistrateDocument(data?: RegistrationData, callFunction?: Function): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegistrationDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegistrationDocumentService>;
}

declare class SlnBaseAuthSigninComponent extends CoreSimplePage implements OnInit {
    _route: ActivatedRoute;
    _authService: AuthorizationService;
    _cryptoM: CryptoSignService;
    _dialog: MatDialog;
    protected _service: RegistrationService;
    protected _router: Router;
    private _documentService;
    protected _popUp: PopupResults;
    private _sessionStorage;
    returnUrl: string;
    hidePassword: boolean;
    dynamicMask: string;
    loginInputTitle: string;
    loginByPhone: boolean;
    user: LoginModel;
    get loginByPhoneEnabled(): boolean;
    constructor(injector: Injector, _route: ActivatedRoute, _authService: AuthorizationService, _cryptoM: CryptoSignService, _dialog: MatDialog, _service: RegistrationService, _router: Router, _documentService: RegistrationDocumentService, _popUp: PopupResults, _sessionStorage: BrowserSessionStorage);
    ngOnInit(): void;
    login(): void;
    loginByCert(needRegister?: boolean): void;
    private _register;
    private _registerInternal;
    protected handlePhoneNumberLoginLogic(): void;
    protected handleLoginLogic(errorCallback?: Function): void;
    handleCheckbox($event: any): void;
    handleButton($event: any): void;
    handleButtonChange($event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnBaseAuthSigninComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnBaseAuthSigninComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class OAuthModel {
    grant_type: string;
    client_id: string;
    username: string;
    password: string;
    signature: string;
    code_challenge: string;
    constructor(model: LoginModel);
}

declare enum AccessLvl {
    V = 0,// просмотр
    A = 1,// добавление
    E = 2,// редактирование
    D = 3
}
declare class RouteAccessParam {
    level: AccessLvl;
    sysObject: string;
}

declare enum InlineDictionaryAction {
    Add = "add",
    Cancel = "cancel",
    Save = "save"
}
interface InlineDictionaryConf {
    type: string;
    saved: string;
    item?: any;
}
interface InlineDictionaryResult {
    method: string;
    item?: ISimpleComboboxItem;
}
declare class CoreEditInlineDictionaryComponent extends CoreBaseDestroyComponent implements OnInit, OnDestroy {
    private _injector;
    private _ajaxM;
    private _popup;
    inlineAdd: string;
    method: InlineDictionaryAction;
    loaded: boolean;
    editMode: boolean;
    item: any;
    conf: InlineDictionaryConf;
    editEv: EventEmitter<InlineDictionaryResult>;
    constructor(_injector: Injector, _ajaxM: AjaxService, _popup: PopupResults);
    ngOnInit(): void;
    ngOnDestroy(): void;
    add(): void;
    cancel(): void;
    save(): void;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreEditInlineDictionaryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreEditInlineDictionaryComponent, "core-inline-dic-item", never, { "conf": { "alias": "conf"; "required": false; }; }, { "editEv": "editEv"; }, never, never, false, never>;
}

declare abstract class CoreAbstractDictionaryCommonComponent extends CoreAbstractComponent {
    detail: boolean;
    session: UserSessionData;
    isFirstLoading: boolean;
    loaded: boolean;
    prefix: string;
    item: any;
    finish: EventEmitter<any>;
    valuesChange: EventEmitter<any>;
    get isSystem(): boolean;
    constructor(injector: Injector);
    onNameChange($event: string): void;
    onValuesChange($event: any): void;
    showDetail(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAbstractDictionaryCommonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAbstractDictionaryCommonComponent, "ng-component", never, { "loaded": { "alias": "loaded"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, { "finish": "finish"; "valuesChange": "valuesChange"; }, never, never, false, never>;
}

declare class CoreDictionaryCommonComponent extends CoreAbstractDictionaryCommonComponent implements OnInit {
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDictionaryCommonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDictionaryCommonComponent, "core-dictionary-common", never, {}, {}, never, ["*"], false, never>;
}

declare class CoreDictionaryFileTypeComponent extends CoreAbstractDictionaryCommonComponent implements OnInit {
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDictionaryFileTypeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDictionaryFileTypeComponent, "core-dictionary-file-type", never, {}, {}, never, ["*"], false, never>;
}

declare class CoreDictionaryStatusComponent extends CoreAbstractDictionaryCommonComponent implements OnInit {
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDictionaryStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreDictionaryStatusComponent, "core-dictionary-status", never, {}, {}, never, ["*"], false, never>;
}

declare class CoreDictionaryModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDictionaryModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDictionaryModule, [typeof CoreEditInlineDictionaryComponent, typeof CoreDictionaryCommonComponent, typeof CoreDictionaryFileTypeComponent, typeof CoreDictionaryStatusComponent], [typeof CoreMatModule, typeof CoreDialogModule, typeof CoreControlModule, typeof CoreBaseModule], [typeof CoreEditInlineDictionaryComponent, typeof CoreDictionaryCommonComponent, typeof CoreDictionaryFileTypeComponent, typeof CoreDictionaryStatusComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDictionaryModule>;
}

interface EditDictionaryItemOptions {
    isNew: boolean;
    saveUrl: string;
    item?: any;
    organizationId?: number;
}

interface IStatusItem extends IEditDictionaryItem {
    statusGroup: ISimpleComboboxItem;
    metadata: IStatusMetadata;
    sort: number;
}
declare class StatusItem extends EditDictionaryItem implements IStatusItem {
    statusGroup: ISimpleComboboxItem;
    metadata: IStatusMetadata;
    sort: number;
    constructor();
}
interface IStatusMetadata {
    needComment: boolean;
    brokerEditable: boolean;
    hidden: IStatusRoleMetadata;
}
declare class StatusMetadata implements IStatusMetadata {
    needComment: boolean;
    brokerEditable: boolean;
    hidden: IStatusRoleMetadata;
    constructor();
}
interface IStatusRoleMetadata {
    forCustomer: boolean;
    forBroker: boolean;
    forProvider: boolean;
}

declare enum SystemObjectSelectedType {
    OnlySystem = 1,
    NotSystem = 2,
    All = 3
}

declare enum NationalityEnum {
    Russian = "Russian",
    NoCitizenship = "NoCitizenship",
    Other = "Other"
}
declare enum DocumentTypeEnum {
    None = 1,
    Passport = 2,
    InternationalPassport = 3,
    MigrationCard = 18,
    Visa = 19,
    TemporaryResidencePermits = 20,
    ResidencePermits = 21
}
interface IDocument {
    documentType: ISimpleComboboxItem;
    otherDocumentType: string;
    serial: string;
    number: string;
    authority: string;
    issueDate: Date;
    code: string;
    dateFrom: Date;
    dateTo: Date;
    files: UploadedFile[];
    toString: string;
}
declare class Document$1 implements IDocument {
    documentType: ISimpleComboboxItem;
    otherDocumentType: string;
    serial: string;
    number: string;
    authority: string;
    issueDate: Date;
    code: string;
    dateFrom: Date;
    dateTo: Date;
    files: UploadedFile[];
    get toString(): string;
}
interface IIdentificationDocument {
    personIdentificationDocumentId: number;
    personId: number;
    birthDay: Date;
    birthPlace: string;
    nationalityCountry: ISimpleComboboxItem;
    identificationDocument: IDocument;
    isNeedResidencePermitDocument: boolean;
    residencePermitDocument: IDocument;
}
declare class IdentificationDocument implements IIdentificationDocument {
    personIdentificationDocumentId: number;
    personId: number;
    birthDay: Date;
    birthPlace: string;
    nationalityCountry: ISimpleComboboxItem;
    identificationDocument: IDocument;
    isNeedResidencePermitDocument: boolean;
    residencePermitDocument: IDocument;
    constructor();
}

declare class IIdentificationDocumentDialogOptions {
    item: IIdentificationDocument;
    readonlyMode: boolean;
    personId?: number;
    passportDataMode?: boolean;
}
declare class CoreIdentificationDocumentDialogWindow extends CoreAbstractComponent {
    dialogRef: MatDialogRef<CoreIdentificationDocumentDialogWindow>;
    data: IIdentificationDocumentDialogOptions;
    constructor(dialogRef: MatDialogRef<CoreIdentificationDocumentDialogWindow>, data: IIdentificationDocumentDialogOptions);
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreIdentificationDocumentDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreIdentificationDocumentDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreIdentificationDocCardComponent extends CoreAbstractComponent implements OnInit {
    readonly: boolean;
    section: string;
    item: IIdentificationDocument;
    passportDataMode: boolean;
    valueChange: EventEmitter<any>;
    nationality: NationalityEnum;
    identificationDocumentConfig: UploaderConfig;
    residencePermitDocumentConfig: UploaderConfig;
    russianIdentificationDocumentIds: number[];
    noCitizenshipIdentificationDocumentIds: number[];
    otherIdentificationDocumentIds: number[];
    get nowDate(): Date;
    get minDate(): Date;
    ngOnInit(): void;
    onNationalityChange(value: NationalityEnum): void;
    onIdentificationDocumentTypeChange(value: DocumentTypeEnum): void;
    private _changeNationalityLogic;
    private _changeDocumentTypeLogic;
    private _resetOtherDocumentType;
    onResinencePermitDocumentChanged($event: any): void;
    onFmsUnitSelected($event: any): void;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreIdentificationDocCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreIdentificationDocCardComponent, "core-identification-doc-card", never, { "readonly": { "alias": "readonly"; "required": false; }; "section": { "alias": "section"; "required": false; }; "item": { "alias": "item"; "required": false; }; "passportDataMode": { "alias": "passportDataMode"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class CoreFieldIdentificationDocComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit {
    private _dialog;
    passportDataMode: boolean;
    isDialogOppened: boolean;
    isValueSaved: boolean;
    get isImageEmpty(): boolean;
    constructor(_dialog: MatDialog);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    editValue(): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldIdentificationDocComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldIdentificationDocComponent, "core-field-identification-doc", never, { "passportDataMode": { "alias": "passportDataMode"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreIdentificationDocumentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreIdentificationDocumentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreIdentificationDocumentModule, [typeof CoreIdentificationDocumentDialogWindow, typeof CoreIdentificationDocCardComponent, typeof CoreFieldIdentificationDocComponent], [typeof CoreMatModule, typeof CoreDialogModule, typeof CoreControlModule, typeof CoreUploaderModule, typeof CoreBaseModule, typeof CoreDaDataModule, typeof CoreDirectiveModule], [typeof CoreIdentificationDocumentDialogWindow, typeof CoreIdentificationDocCardComponent, typeof CoreFieldIdentificationDocComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreIdentificationDocumentModule>;
}

interface ILicense {
    licenseId: number;
    organizationId: number;
    kindOfActivity: string;
    description: string;
    number: string;
    issueDate: Date;
    authority: string;
    isIndefinite: boolean;
    dateFrom: Date;
    dateTo: Date;
}
declare class License implements ILicense {
    licenseId: number;
    organizationId: number;
    kindOfActivity: string;
    description: string;
    number: string;
    issueDate: Date;
    authority: string;
    isIndefinite: boolean;
    dateFrom: Date;
    dateTo: Date;
    constructor();
}

declare class CoreLicenseCardComponent extends CoreAbstractComponent {
    readonly: boolean;
    item: ILicense;
    valueChange: EventEmitter<any>;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLicenseCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreLicenseCardComponent, "core-license-card", never, { "readonly": { "alias": "readonly"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class ILicenseDialogOptions {
    item: ILicense;
    readonlyMode: boolean;
    organizationId?: number;
}
declare class CoreLicenseDialogWindow extends CoreAbstractComponent {
    private dialogRef;
    data: ILicenseDialogOptions;
    constructor(dialogRef: MatDialogRef<CoreLicenseDialogWindow>, data: ILicenseDialogOptions);
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLicenseDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreLicenseDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreFieldLicenseComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit {
    private _dialog;
    get isImageEmpty(): boolean;
    constructor(_dialog: MatDialog);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    editValue(): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldLicenseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldLicenseComponent, "core-field-license", never, {}, {}, never, never, false, never>;
}

declare class CoreLicenseModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLicenseModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreLicenseModule, [typeof CoreLicenseCardComponent, typeof CoreLicenseDialogWindow, typeof CoreFieldLicenseComponent], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreDialogModule, typeof CoreDirectiveModule, typeof CoreControlModule, typeof CorePipeModule], [typeof CoreLicenseDialogWindow, typeof CoreLicenseCardComponent, typeof CoreFieldLicenseComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreLicenseModule>;
}

interface IRequisites {
    requisiteId: number;
    organizationId: number;
    organizationName: string;
    organizationInn?: string;
    organizationKpp?: string;
    account: string;
    accountType: ISimpleComboboxItem;
    correspondentAccount: string;
    bik: string;
    inn?: string;
    kpp?: string;
    bankName: string;
    bankAddress: string;
    enabled: boolean;
}
declare class Requisites implements IRequisites {
    requisiteId: number;
    organizationId: number;
    organizationName: string;
    organizationInn?: string;
    organizationKpp?: string;
    account: string;
    accountType: ISimpleComboboxItem;
    correspondentAccount: string;
    bik: string;
    inn?: string;
    kpp?: string;
    bankName: string;
    bankAddress: string;
    enabled: boolean;
    constructor();
}

declare class IRequisiteDialogOptions {
    item: IRequisites;
    readonlyMode: boolean;
    organizationId?: number;
    requisitesMode?: RequisitsMode;
}
declare class CoreRequisiteDialogWindow extends CoreAbstractComponent {
    private _dialog;
    private dialogRef;
    data: IRequisiteDialogOptions;
    constructor(_dialog: MatDialog, dialogRef: MatDialogRef<CoreRequisiteDialogWindow>, data: IRequisiteDialogOptions);
    checkRequisiteAccount(account: string, mode: 'All' | 'Fiz' | 'Jur'): string | null;
    save(): void;
    isValid(item: IRequisites): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreRequisiteDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreRequisiteDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreRequisiteCardComponent extends CoreAbstractComponent implements OnInit {
    configBank: DadataConfig;
    readonly: boolean;
    item: IRequisites;
    selected: boolean;
    valueChange: EventEmitter<any>;
    ngOnInit(): void;
    onBankSelected(event: DadataSuggestion): void;
    onValuesChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreRequisiteCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreRequisiteCardComponent, "core-requisite-card", never, { "readonly": { "alias": "readonly"; "required": false; }; "item": { "alias": "item"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class CoreFieldRequisiteComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnDestroy, OnInit {
    private _dialog;
    get isImageEmpty(): boolean;
    constructor(_dialog: MatDialog);
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    setDefault(): void;
    editValue(): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldRequisiteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldRequisiteComponent, "core-field-requisite", never, {}, {}, never, never, false, never>;
}

declare class CoreRequisiteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreRequisiteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreRequisiteModule, [typeof CoreRequisiteDialogWindow, typeof CoreRequisiteCardComponent, typeof CoreFieldRequisiteComponent], [typeof CorePipeModule, typeof CoreMatModule, typeof CoreControlModule, typeof CoreDaDataModule, typeof CoreDialogModule, typeof CoreBaseModule, typeof CoreDirectiveModule], [typeof CoreRequisiteDialogWindow, typeof CoreRequisiteCardComponent, typeof CoreFieldRequisiteComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreRequisiteModule>;
}

declare class RequisiteService {
    protected _startUp: Startup;
    protected _ajaxM: AjaxService;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getSimple(itemId: number): Observable<any>;
    save(item: IRequisites): Observable<any>;
    isValid(item: IRequisites): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequisiteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RequisiteService>;
}

declare class UploaderConst {
    static converFilter: Record<string, Partial<any>>;
}

declare class DrawerNames {
    static LIST: string;
    static USER_LIST: string;
    static GROUP: string;
    static DIALOG: string;
    static PROFILE: string;
    static FORWARD: string;
}

interface ICompositeAccessItem {
    id?: number | string;
    bitPosition: number;
    systemRole?: ISimpleComboboxItem;
    department?: ISimpleComboboxItem;
    participationType?: ISimpleComboboxItem;
    enabled: boolean;
    value?: boolean;
}

declare class CompositeAccessSchemaService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getGlobalItems(): Observable<any>;
    getRedefinitionItems(organizationId?: number): Observable<any>;
    setRedefinitionItems(items: ICompositeAccessItem[], organizationId?: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompositeAccessSchemaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CompositeAccessSchemaService>;
}

declare abstract class BaseAccessSchemaComponent extends CoreBaseDestroyComponent implements OnInit {
    _storage: BrowserLocalStorage;
    _service: CompositeAccessSchemaService;
    _popup: PopupResults;
    STORAGE_KEY: string;
    isGlobal: boolean;
    storageKey: string;
    getItemFunction: () => Observable<any>;
    isInherited: boolean;
    isUseEveryone: boolean;
    items: ICompositeAccessItem[];
    constructor(_storage: BrowserLocalStorage, _service: CompositeAccessSchemaService, _popup: PopupResults);
    ngOnInit(): void;
    abstract getData(): number;
    private _getItems;
    loadCoreAccessSchema(): void;
    recalculateSchema(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseAccessSchemaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseAccessSchemaComponent, "ng-component", never, { "isGlobal": { "alias": "isGlobal"; "required": false; }; "storageKey": { "alias": "storageKey"; "required": false; }; "getItemFunction": { "alias": "getItemFunction"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreCompositeAccessSchemaEditComponent extends BaseAccessSchemaComponent implements OnInit {
    data?: number;
    canInherited?: boolean;
    valueChange: EventEmitter<any>;
    get canUseEveryone(): boolean;
    constructor(storage: BrowserLocalStorage, service: CompositeAccessSchemaService, popup: PopupResults);
    ngOnInit(): void;
    getData(): number;
    makeName(item: ICompositeAccessItem): string;
    onValueChange(): void;
    private _iml;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCompositeAccessSchemaEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreCompositeAccessSchemaEditComponent, "core-access-schema", never, { "data": { "alias": "data"; "required": false; }; "canInherited": { "alias": "canInherited"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class CoreCompositeAccessSchemaLabelComponent extends BaseAccessSchemaComponent implements OnInit {
    private _data;
    get data(): number;
    set data(v: number);
    get mixItems(): any[];
    constructor(storage: BrowserLocalStorage, service: CompositeAccessSchemaService, popup: PopupResults);
    ngOnInit(): void;
    getData(): number;
    makeName(item: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCompositeAccessSchemaLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreCompositeAccessSchemaLabelComponent, "core-access-schema-label", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum ParticipationDisplayMode {
    All = 0,
    System = 1
}
declare class CoreAccessSchemaSettingsComponent extends CoreBaseDestroyComponent implements OnInit {
    private _service;
    private _popup;
    participationMode: number;
    isSystem: boolean;
    items: ICompositeAccessItem[];
    isGlobal?: boolean;
    organizationId?: number;
    getDataFunction: (organizationId?: number) => Observable<any>;
    valuesChange: EventEmitter<any>;
    get excludedValues(): ISimpleComboboxItem[];
    constructor(_context: ContextService, _service: CompositeAccessSchemaService, _popup: PopupResults);
    ngOnInit(): void;
    onValueChange($event?: any): void;
    onKeyValueChange(index: number): void;
    add(): void;
    ban(index: number): void;
    remove(index: number): void;
    private _reloadData;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAccessSchemaSettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAccessSchemaSettingsComponent, "core-access-schema-settings", never, { "isGlobal": { "alias": "isGlobal"; "required": false; }; "organizationId": { "alias": "organizationId"; "required": false; }; "getDataFunction": { "alias": "getDataFunction"; "required": false; }; }, { "valuesChange": "valuesChange"; }, never, never, false, never>;
}

interface IAccessSchemaSettingsDialogOptions {
    isGlobal?: boolean;
    organizationId?: number;
    storageKey?: string;
    getDataFunction?: (organizationId?: number) => Observable<any>;
    setDataFunction?: (items: ICompositeAccessItem[], organizationId?: number) => Observable<any>;
}
declare class CoreAccessSchemaSettingsDialogWindow extends CoreBaseDestroyComponent {
    data: IAccessSchemaSettingsDialogOptions;
    private _dialogRef;
    private _service;
    private _popup;
    private _storage;
    processId: number;
    items: ICompositeAccessItem[];
    constructor(data: IAccessSchemaSettingsDialogOptions, _dialogRef: MatDialogRef<CoreAccessSchemaSettingsDialogWindow>, _service: CompositeAccessSchemaService, _popup: PopupResults, _storage: BrowserLocalStorage);
    onValueChange($event: ICompositeAccessItem[]): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreAccessSchemaSettingsDialogWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreAccessSchemaSettingsDialogWindow, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CoreCompositeAccessSchemaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreCompositeAccessSchemaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreCompositeAccessSchemaModule, [typeof CoreCompositeAccessSchemaEditComponent, typeof CoreCompositeAccessSchemaLabelComponent, typeof CoreAccessSchemaSettingsComponent, typeof CoreAccessSchemaSettingsDialogWindow], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreControlModule, typeof CoreDialogModule, typeof CoreDirectiveModule], [typeof CoreCompositeAccessSchemaEditComponent, typeof CoreCompositeAccessSchemaLabelComponent, typeof CoreAccessSchemaSettingsComponent, typeof CoreAccessSchemaSettingsDialogWindow]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreCompositeAccessSchemaModule>;
}

declare class CoreFieldFilterEditComponent extends CoreAbstractAccessorComponent implements ControlValueAccessor, Validator, OnInit {
    processId: number;
    systemObjectId: number;
    display: string;
    sizeClass: string;
    suffix: string;
    showAddition: boolean;
    constructor();
    ngOnInit(): void;
    writeLogic(model: any): void;
    disabledLogic(isDisabled: boolean): void;
    formatValue(model: any): any;
    onChangeAddtionView($event: any): void;
    onInternalValueChange($event: any): void;
    validate(control: AbstractControl<any, any>): ValidationErrors;
    registerOnValidatorChange?(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldFilterEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldFilterEditComponent, "core-field-filter-edit", never, { "processId": { "alias": "processId"; "required": false; }; "systemObjectId": { "alias": "systemObjectId"; "required": false; }; "display": { "alias": "display"; "required": false; }; "sizeClass": { "alias": "sizeClass"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; }, {}, never, never, false, never>;
}

interface IFieldFilter {
    fieldName: ISimpleComboboxItem;
    condition: ISimpleComboboxItem;
    value: string;
    module: string;
}
declare class FieldFilter implements IFieldFilter {
    fieldName: ISimpleComboboxItem;
    condition: ISimpleComboboxItem;
    value: string;
    module: string;
    constructor();
}

declare class CoreFieldFilterViewComponent extends CoreAbstractComponent {
    value: IFieldFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldFilterViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreFieldFilterViewComponent, "core-field-filter-view", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoreFieldFiltersModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFieldFiltersModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreFieldFiltersModule, [typeof CoreFieldFilterEditComponent, typeof CoreFieldFilterViewComponent], [typeof CoreBaseModule, typeof CoreMatModule, typeof CoreControlModule, typeof CorePipeModule], [typeof CoreFieldFilterEditComponent, typeof CoreFieldFilterViewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreFieldFiltersModule>;
}

declare class ImportedField {
    name: string;
    caption: string;
    isRequired: boolean;
    fieldType: string;
    mapping: ISimpleComboboxItem;
    dictionaryValues: ISimpleComboboxItem[];
}

declare class ImportModel {
    systemObjectId: number;
    importArea: ImportArea;
    fields: ImportedField[];
}
declare class ImportFile {
    fileId: string;
    worksheets: ISimpleComboboxItem[];
    defaultArea: ImportArea;
    defaultFields: ISimpleComboboxItem[];
}
declare class ImportArea {
    fileId: string;
    worksheetPosition: number;
    headerRange: string;
    dataRange: string;
}

declare class ImportService {
    private _startUp;
    private _ajaxM;
    constructor(_startUp: Startup, _ajaxM: AjaxService);
    getFields(systemObjectId: number, api?: string): Observable<IEntityResponse>;
    import(model: ImportModel, api?: string): Observable<IResponse>;
    getImportArea(fileId: string, worksheetNum: number): Observable<IEntityResponse>;
    getColumns(model: ImportArea): Observable<IEntityResponse>;
    getImportResult(model: ImportModel): Observable<IResponse>;
    private getApiName;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ImportService>;
}

declare class CoreImportWindow extends CoreBaseDestroyComponent implements OnInit {
    private _service;
    private _popUp;
    private _dialogRef;
    data: any;
    private _startUp;
    private _userSettingsService;
    htmlBaner: string;
    uploadedFileConfig: UploaderConfig;
    model: ImportModel;
    step: number;
    importFile: ImportFile;
    worksheets: Observable<any>;
    columns: Observable<any>;
    isInitialLoading: boolean;
    settingKey: string;
    session: UserSessionData;
    settingValue: any;
    defaultFields: ISimpleComboboxItem[];
    get title(): string;
    constructor(_service: ImportService, _popUp: PopupResults, injector: Injector, _dialogRef: MatDialogRef<CoreImportWindow>, data: any, _startUp: Startup, _userSettingsService: CoreUserSettingsService);
    ngOnInit(): void;
    next(): void;
    import(): void;
    getMapping(field: ImportedField): Observable<any>;
    onEntityChange(e: any): void;
    onWorksheetChange(e: any): void;
    private loadFields;
    private getSettingKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreImportWindow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoreImportWindow, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class CoreModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, never, [typeof CoreLayoutModule, typeof CoreMatModule, typeof CoreControlModule, typeof CoreDialogModule, typeof CoreContactVerificationModule, typeof i6$2.CryptoModule], [typeof CoreLayoutModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
}

declare global {
    interface Window extends Record<string, any> {
        ResizeDelegats: any;
        DrowersStack: any[];
        sellan_platform: any[];
        sellan_injector_instance: any;
        signalR: {
            HubConnectionBuilder: {
                new (): {
                    withUrl(url: string, options?: any): any;
                    configureLogging(level: any): any;
                    build(): any;
                };
            };
            HttpTransportType: {
                WebSockets: number;
                LongPolling: number;
                ServerSentEvents: number;
                None: number;
            };
            LogLevel: {
                Trace: number;
                Debug: number;
                Information: number;
                Warning: number;
                Error: number;
                Critical: number;
                None: number;
            };
            HubConnectionState: {
                Connecting: number;
                Connected: number;
                Disconnecting: number;
                Disconnected: number;
                Reconnecting: number;
            };
        };
    }
    interface Navigator {
        msSaveBlob?: (blob: any, defaultName?: string) => boolean;
    }
}

export { ALL_HOURS, ALL_MINUTES, ALTERNATIVE_FILTER_CONDITIONS, APP_DATE_FORMATS, AbstractStorage, AccessGuard, AccessLvl, AccessManager, Address, AgentService, AjaxService, Align, ArrayExtension, AuthBlockedUserInstructionDialogWindow, AuthorityEnum, AuthorizationService, AvatarEntity, BooleanExtension, BooleanMode, BooleanPipe, BrokerVisualSetting, BrokeredEvent, BrowserCookieStorage, BrowserLocalStorage, BrowserSessionStorage, ButtonLoadingService, CORE_DRAWER_DATA_TOKEN_KEY, CORE_NOTIFICATION_DATA_TOKEN, CardButton, CardEditButtonsComponent, CardFrame, CardPanel, CardPanelComponent, Certificate, CertificateListComponent, CertificateListWindow, Chat, ClientSideDataSource, CollapseDirective, CommonVisualSetting, CompositeAccessSchemaService, ContextService, ConversionDatePipe, CookieStorage, CopyClipboardDirective, CoreAbstractAccessorComponent, CoreAbstractComponent, CoreAbstractDictionaryCommonComponent, CoreAbstractVerificationComponent, CoreAccessSchemaSettingsComponent, CoreAccessSchemaSettingsDialogWindow, CoreAddressCardComponent, CoreAddressDialogWindow, CoreAddressModule, CoreAttorneyModule, CoreAttorneyUploadWindow, CoreAuthModule, CoreAvatarCropperDialogWindow, CoreAvatarService, CoreBaseDestroyComponent, CoreBaseModule, CoreBasePage, CoreChatAvatarComponent, CoreChatDialodReadingMessageTooltipComponent, CoreChatDialogDrawerComponent, CoreChatDialogMenuComponent, CoreChatForwardDrawerComponent, CoreChatListDrawerComponent, CoreChatListMenuComponent, CoreChatMessageMenuComponent, CoreChatNewDrawerComponent, CoreChatNewGroupDrawerComponent, CoreChatProfileDrawerComponent, CoreChatRoomComponent, CoreChatService, CoreChatUserComponent, CoreChatWidgetBalloonsComponent, CoreClientGrid, CoreComboboxService, CoreCompositeAccessSchemaEditComponent, CoreCompositeAccessSchemaLabelComponent, CoreCompositeAccessSchemaModule, CoreConfirmDialogWindow, CoreContactVerificationModule, CoreControlModule, CoreCropperJsModule, CoreCropperModule, CoreCropperService, CoreCryptoModule, CoreDaDataModule, CoreDadataFmsCodeComponent, CoreDadataSearchComponent, CoreDawerBaseOverlayConfig, CoreDialog, CoreDialogModule, CoreDialogWindow, CoreDictionaryCommonComponent, CoreDictionaryFileTypeComponent, CoreDictionaryModule, CoreDictionaryStatusComponent, CoreDirectiveModule, CoreDrawerComponent, CoreDrawerModule, CoreEditInlineDictionaryComponent, CoreErrorPage, CoreFieldAddressComponent, CoreFieldColorComponent, CoreFieldEmailComponent, CoreFieldFilterEditComponent, CoreFieldFilterViewComponent, CoreFieldFiltersModule, CoreFieldIdentificationDocComponent, CoreFieldInnComponent, CoreFieldIpComponent, CoreFieldKppComponent, CoreFieldLicenseComponent, CoreFieldOgrnComponent, CoreFieldOrganizationComponent, CoreFieldPasswordComponent, CoreFieldPhoneComponent, CoreFieldRequisiteComponent, CoreFieldSnilsComponent, CoreFieldTelegramComponent, CoreFieldTypeBoolComponent, CoreFieldTypeComboboxComponent, CoreFieldTypeDateTimeComponent, CoreFieldTypeMultipleComboboxComponent, CoreFieldTypeNumberComponent, CoreFieldTypeStringComponent, CoreFieldTypeTextareaComponent, CoreFieldTypeTimeComponent, CoreFileAttributesModule, CoreFileAttributesWindow, CoreFilePreviewDialogWindow, CoreFileSignaturesComponent, CoreFileSignaturesModule, CoreFileSignaturesWindow, CoreFileUploaderComponent, CoreFilterOrganizationComponent, CoreFilterOrganizationInternalComponent, CoreForbiddenPage, CoreGirdDynamicPipe, CoreGrid, CoreGridAlignButtonsComponent, CoreGridColumnTemplateComponent, CoreGridConfigUserColumnDialogWindow, CoreGridDialogFilterComponent, CoreGridExportModeDialogWindow, CoreGridFilterBaseComponent, CoreGridFilterTemplateComponent, CoreGridFiltersComponent, CoreGridModule, CoreGridUtility, CoreIdentificationDocCardComponent, CoreIdentificationDocumentDialogWindow, CoreIdentificationDocumentModule, CoreImportWindow, CoreInfoDialogWindow, CoreLabelComponent, CoreLayoutModule, CoreLicenseCardComponent, CoreLicenseDialogWindow, CoreLicenseModule, CoreMatModule, CoreMiniDraftDialogWindow, CoreModule, CoreNotFoundPage, CoreNotification, CoreNotificationBaseOverlayConfig, CoreNotificationModule, CoreNotificationQueueService, CoreNotificationService, CoreNotificationUIConfig, CoreOrganizationDialogWindow, CoreOrganizationInfoComponent, CoreOrganizationModule, CoreOrganizationSearchComponent, CorePage, CorePageContentComponent, CorePageTitleComponent, CorePipeModule, CoreRequisiteCardComponent, CoreRequisiteDialogWindow, CoreRequisiteModule, CoreRouteDescription, CoreSelectSearchComponent, CoreServerGridComponent, CoreSimplePage, CoreStepperComponent, CoreStepperModule, CoreTitlePage, CoreTooltipContainerComponent, CoreTooltipDirective, CoreTooltipModule, CoreUploaderModule, CoreUrlSerializer, CoreUserIconComponent, CoreUserSettingsService, CoreVerificationDialogWindow, CropService, CropperPositionService, CropperSettings, CrudService, CryptoSignService, CryptoSignature, DEFAULT_COUNTER_ID, DEFAULT_COUNTER_ID_AOT, DadataConfigDefault, DadataIntegrationService, DadataType, DataExportService, DataGridComponentTemplate, DateAndTimePipe, DateCompareOption, DateExtension, Deepmerge, DefaultComboboxUriDescriptionService, DefaultQueueService, DeleteStatus, DiagInfo, DiagService, DialogConfirmReason, DialogReason, DictionaryItem, DigitMaxDirective, DigitMinDirective, Division, Document$1 as Document, DocumentTypeEnum, DragUploudDirective, DrawerConfig, DrawerNames, DrawerService, EditDictionaryItem, EqualValidatorDirective, EventBrokerService, EventListener, Exception, ExportMode, ExportedData, ExternalRedirectComponent, FederationEntity, FederationLoader, FieldFilter, FieldSetting, FieldTypeEnum, FileDataForSign, FileTypeEnum, FileTypeItem, FileViewerDialogWindow, FilesLabel, FilterCmbxPipe, GridColumn, GridConfiguration, GridConfigutarionService, GridDataEvent, Guid, HotkeyDirective, IAddressDialogOptions, IChatConfig, IIdentificationDocumentDialogOptions, ILicenseDialogOptions, IOrgnizationDialogOptions, IRequisiteDialogOptions, IdentificationDocument, ImageCropperComponent, ImportArea, ImportFile, ImportModel, ImportService, ImportedField, InfoDiologConfig, InfoOrganization, InfoType, InfoUser, InlineDictionaryAction, InnDirective, InvalidFormService, KONTUR_AUTH_SUCCESS_MESSAGE_TYPE, KonturAuthService, License, LoadImageService, LocalStorage, LogService, LoginModel, LongTastService, MAT_DATE_TIME_LOCALE_FACTORY, MAT_DEFAULT_ACITONS, MAT_TIMEPICKER_DEFAULT_OPTIONS, MAT_TIMEPICKER_SCROLL_STRATEGY, MAT_TIMEPICKER_SCROLL_STRATEGY_FACTORY, MAT_TIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_TIMEPICKER_VALIDATORS, MAT_TIMEPICKER_VALUE_ACCESSOR, MAT_TIME_LOCALE, MAT_TIME_LOCALE_PROVIDER, MaskPipe, MatClockDials, MatContextMenuTrigger, MatHourInput, MatHoursClockDial, MatMinuteInput, MatMinutesClockDial, MatNativeDateTimeModule, MatTimeInputs, MatTimePeriod, MatTimepicker, MatTimepickerActions, MatTimepickerApply, MatTimepickerBase, MatTimepickerCancel, MatTimepickerContent, MatTimepickerContentLayout, MatTimepickerDefaultActions, MatTimepickerInput, MatTimepickerInputBase, MatTimepickerInputEvent, MatTimepickerIntl, MatTimepickerModule, MatTimepickerToggle, MatTimepickerToggleIcon, MenuItem, MenuService, MenuSetting, Message, MessageHistory, MessageStatus, MethodOptions, Metrika, MetrikaModule, MfaDialogWindow, MfaProviderService, MiddleEllipsisPipe, MiniDraftModeEnum, MiniDraftService, MoneyPipe, NationalityEnum, NativeDateTimeAdapter, NativeDateTimeModule, NewMsgMode, NotificationDetailService, NotificationInfoType, NumberExtension, OAuthModel, ObjectExtension, OrganizationBaseService, OrganizationItem, OrganizationItemExtension, OrganizationItemTypes, OrganizationSearchResult, PageService, PaginatorSource, Pair, ParticipationDisplayMode, ParticipationEnum, PasswordValidatorDirective, PercentTransformPipe, PersonVerification, PhoneNumberFormatter, PhoneRuPipe, PhoneVerificationServiceWorkingMode, PlatformVisualSetting, PopupResults, PrettyPrintJsonStringPipe, ProportionPercentPipe, ProvideParentFormDirective, RegistrationData, RegistrationDocumentService, RegistrationMethod, RegistrationService, RegistrationType, RequestVisualSettings, RequiredFileValidatorDirective, RequisiteService, Requisites, RequisitsMode, RolesEnum, RouteAccessParam, RuDateAdapter, RuDatePipe, RuDateTimePipe, SLN_CORE_COMBOBOX_SOURCE, SLN_INVALID_FORM_TAB_ACTIVATE_EVENT, SafePipe, SelectedChatUserFilterPipe, SellanChatCommonModule, SellanChatHighlighterPipe, SellanChatInputComponent, SellanChatMessageService, SellanChatMsgManagerService, SellanChatSearchMessageComponent, SellanChatSendMessageMenuComponent, SellanChatUsersService, SellanCoreChatModule, ServerSideDataSource, SessionStorage, SignalBaseService, SignalMainModel, SignalRService, SlnBaseAuthRecoveryComponent, SlnBaseAuthRecoveryDoneComponent, SlnBaseAuthSigninComponent, SnilsDirective, Startup, StatusItem, StatusMetadata, StepperAdditionalPipe, StepperEnabledPipe, StorageCheck, StorageDataGridFilter, StringExtension, SupportDialogWindow, SystemObjectSelectedType, TPair, TimeAdapter, TopicRequest, TopicSubject, TwoFactorService, UnauthorizedInterceptor, UploadedFile, UploadedFileAttribute, UploaderConfig, UploaderConst, UserAdditionalSettingsDto, UserMenuSettings, UserMenuSettingsItem, UserSessionData, UserVerificationMode, Utility, VerificationChannel, VerificationDirective, VerificationFlow, VerificationService, ViewMode, VirtualAccount, VisualSettingManager, VisualSettings, YANDEX_COUNTERS_CONFIGS, YANDEX_COUNTERS_CONFIGS_AOT, YandexCounterConfig, ZeroLeftPadPipe, appInitializerFactory, countersFactory, createConfigs, createCounter, createDaDataFmsValidator, createDaDataValidator, dateReviver, defaultCounterIdFactory, defaultMergeReducer, defineDefaultId, getCounterNameById, insertMetrika, localStorageSync, provideNativeDateTimeAdapter, provideParentForm, rehydrateApplicationState, scrollFactory, syncStateUpdate, timeInputsHaveChanged, СoreNotificationComponent };
export type { Access, Actions, ArrayMergeOptions, Bound, Bounds, CallbackOptions, ClockDialViewCell, CommonOptions, ConfirmDialogOptions, CounterConfig, CropperOptions, CropperPosition, DadataAddress, DadataBank, DadataConfig, DadataFmsUnit, DadataParty, DadataSuggestion, DadataSuggestionResponse, DeepmergeOptions, DialogResult, Dimensions, DocumentViewerModel, DrawerEvent, EditDictionaryItemOptions, FileHandle, Filtration, FiltrationItem, HintAdditionalData, HitOptions, IAccessSchemaSettingsDialogOptions, IAddUserIntoChat, IAddress, IAnswer, IBrokeredEvent, IBrokeredEventBase, IButton, ICardButton, ICardFrame, ICardPanel, ICertificate, IChangedOrganizationContext, IChatOrganizations, IComboboxUriDescriptionService, ICompositeAccessItem, ICoreGridConfiguration, ICoreNotificationData, ICoreNotificationMessage, ICreateRoomDto, ICryptoSignature, IDataGridColumn, IDataGridComponentTemplate, IDeleteChatMessageDto, IDictionaryItem, IDocument, IEditDictionaryItem, IEntityResponse, IEventListener, IExportedColumn, IFederationEntity, IFieldFilter, IFieldSetting, IFileDataForSign, IFilePreviewOptions, IFileSignProcessItem, IFileTypeItem, IFilterItem, IGridColumn, IGridColumnDepend, IGridConfiguration, IGridConfigurationSaved, IGridSaveUserState, IIdentificationDocument, IInfoOrganization, IInfoUser, ILicense, IMaskedValue, IMethodOptions, INewRoomData, IOrderedObject, IOrganizationComboboxItem, IOrganizationContext, IOrganizationItem, IOrganizationItemExtension, IOrganizationItemTypes, IOrganizationLink, IOrganizationLinkItem, IPair, IPanel, IPanelEditable, IPersonComboboxItem, IPopupResultsOption, IProfileUserChat, IQueryDataSertvice, IQueryDataSertviceAdditionalParams, IRequisites, IResponse, ISellanCoreAuthKonturToken, ISignatureInfo, ISimpleAccess, ISimpleComboboxItem, ISortItem, IStatusItem, IStatusMetadata, IStatusRoleMetadata, IStepsSegment, IStorageDataGridFilter, IUserChat, IUserComboboxItem, IUserSettingsDto, IViewCardModeSettings, ImageCroppedEvent, ImageTransform, InlineDictionaryConf, InlineDictionaryResult, Keys, LoadedImage, LocalStorageConfig, Location, MatDialView, MatTimePeriodType, MatTimepickerControl, MatTimepickerDefaultOptions, MatTimepickerPanel, MfaAskCodeRequest, MfaAskCodeResponse, MfaChallenge, MfaConfirmRequest, MoveStart, MultiActions, NewRequestParams, OutputFormat, Password, PopupEntityResultsOption, PopupResultsOption, RecoveryPassword, SignFileData, SlnInvalidFormTabActivateDetail, TimepickerDropdownPositionX, TimepickerDropdownPositionY, TimepickerFormat, TimepickerMode, TimepickerOpenAs, TimepickerOrientation, VerificationAskData, VerificationAskDialogData, VerificationAskResponse, VerificationSave };
