import * as i0 from '@angular/core';
import { OnInit, AfterViewInit, AfterContentInit, OnDestroy, OnChanges, ElementRef, SimpleChanges, PipeTransform, Renderer2, ViewContainerRef, Injector, ComponentRef, NgModuleFactory, Type, ChangeDetectorRef, ProviderToken, InjectOptions, EventEmitter, TemplateRef, ComponentFactoryResolver, WritableSignal, ComponentFactory, InjectionToken, ModuleWithProviders } from '@angular/core';
import { Subject, Observable, BehaviorSubject, Subscription } from 'rxjs';
import { SafeHtml, SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';
import * as i1 from '@angular/router';
import { NavigationEnd, NavigationStart, Route, Router, ActivatedRoute, ParamMap, Event, ActivatedRouteSnapshot, RouteReuseStrategy, DetachedRouteHandle, CanActivate, UrlTree } from '@angular/router';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { DurationInputArg1, DurationInputArg2, Duration, Moment } from 'moment';
import { IconFont, ContentDensity } from '@fundamental-ngx/core';
import * as i137 from '@angular/forms';
import { ValidatorFn, FormGroup } from '@angular/forms';
import * as i1$1 from '@angular/common';
import { TitleCasePipe } from '@angular/common';
import { Direction } from '@angular/cdk/bidi';

interface IDebug {
    LEVEL_1: boolean;
    LEVEL_2: boolean;
    LEVEL_3: boolean;
    LEVEL_4: boolean;
    LEVEL_5: boolean;
}
declare class LogService {
    static DEBUG: IDebug;
    info(...msg: Array<any>): void;
    debug(...msg: Array<any>): void;
    error(...err: Array<any>): void;
    warn(...warn: Array<any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
}

declare abstract class BaseComponent implements OnInit, AfterViewInit, AfterContentInit, OnDestroy, OnChanges {
    rendered: any;
    protected _el: ElementRef<any>;
    protected _log: LogService;
    protected readonly _onDestroy$: Subject<void>;
    get el(): ElementRef;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseComponent, "bnrc-base", never, { "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, false, never>;
}

declare class EmptyPageWithRouterAndRouterOutletComponent extends BaseComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyPageWithRouterAndRouterOutletComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyPageWithRouterAndRouterOutletComponent, "bnrc-empty-page-with-router-and-router-outlet", never, {}, {}, never, never, false, never>;
}

interface DateInfo {
    year: number;
    month: number;
    day: number;
    hour: number;
    minutes: number;
    strYear: string;
    strMonth: string;
    strDay: string;
    monthName: string;
    dayName: string;
    dayInWeek: number;
    moment: any;
    date: Date;
}

declare abstract class DateService {
    protected logService: LogService;
    protected abstract locale: string;
    protected get now(): Date;
    monthNames(): string[];
    includeDay(date: Date, startDate: Date, endDate: Date): boolean;
    duration(inp: DurationInputArg1, _?: DurationInputArg2): Duration;
    day(date: Date): number;
    getDayStr(mode: 'Today' | 'DaysBefore' | 'DaysAfter'): string;
    getMonthStr(mode: 'ThisMonth' | 'NextMonth' | 'PrevMonth'): string;
    getYearStr(mode: 'ThisYear' | 'PrevYear' | 'NextYear'): number;
    getWeekStr(mode: 'ThisWeek' | 'NextWeek' | 'PrevWeek'): string;
    getWeekRange(mode: 'ThisWeek' | 'NextWeek' | 'PrevWeek'): {
        from: Moment;
        to: Moment;
    };
    format(value: Date, format: string): string;
    getShortDateString(date: Date): string;
    protected checkSame(moment1: any, moment2: any, mode: any, prefix: '' | 'i' | 'j'): boolean;
    abstract subtractMonth(moment: any, value: number): Date;
    abstract addMonth(moment: any, value: number): Date;
    abstract from(date1: Date, date2: Date): string;
    abstract to(date: Date, endDate: Date): string;
    abstract getTimes(date: string | Date): string;
    abstract getDateTimeString(date: Date): string;
    abstract weeksCount(momentObj: any): number;
    abstract isSame(date1: Date, date2: Date, mode: 'year' | 'month' | 'day'): boolean;
    abstract strDate(date: Date): string;
    abstract date(date: Date): number;
    abstract endOfMonth(moment: any): Date;
    abstract startOfMonth(moment: any): Date;
    abstract getDateInfo(date: any): DateInfo;
    abstract daysInMonth(year: any, month: any): number;
    abstract getMoment(date?: Date): any;
    abstract stringToMoment(str: string, format: string): any;
    abstract getStrMonthName(date: Date): string;
    abstract getDateString(date: any, showDate: any, showTime: any): string;
    abstract parse(payload: {
        year: number;
        month: number;
        day: number;
        hour: string;
        minutes: string;
    }): any;
    abstract weekdaysMin(): string[];
    abstract weekDays(): string[];
    abstract toText(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateService>;
}

declare class DateHijriService extends DateService {
    protected locale: string;
    getTimes(date: string | Date): string;
    weeksCount(momentObj: any): number;
    subtractMonth(momentOfDate: any, value: number): Date;
    addMonth(momentOfDate: any, value: number): Date;
    toText(): string;
    to(date1: Date, date2: Date): string;
    from(date1: Date, date2: Date): string;
    isSame(date1: Date, date2: Date, mode: 'year' | 'month' | 'day'): boolean;
    strDate(date: Date): string;
    weekdaysMin(): string[];
    weekDays(): string[];
    date(date: Date): any;
    endOfMonth(date: Date): any;
    startOfMonth(date: Date): any;
    getDateInfo(date: any): DateInfo;
    daysInMonth(year: number, month: number): number;
    getMoment(date?: Date): any;
    stringToMoment(str: string, format: string): any;
    getStrMonthName(date: Date): string;
    parse(payload: {
        year: number;
        month: number;
        day: number;
        hour: string;
        minutes: string;
    }): any;
    monthNames(): string[];
    format(value: Date, format: string): string;
    getShortDateString(date: Date): string;
    getDateTimeString(date: Date): string;
    getDateString(date: Date, showDate: boolean, showTime: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateHijriService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateHijriService>;
}

declare class DateMiladiService extends DateService {
    protected locale: string;
    constructor();
    getTimes(date: string | Date): string;
    weeksCount(momentObj: any): number;
    subtractMonth(momentOfDate: any, value: number): Date;
    addMonth(momentOfDate: any, value: number): Date;
    to(date1: Date, date2: Date): string;
    from(date1: Date, date2: Date): string;
    isSame(date1: Date, date2: Date, mode: 'year' | 'month' | 'day'): boolean;
    strDate(date: Date): string;
    toText(): string;
    date(date: Date): number;
    endOfMonth(date: Date): Date;
    startOfMonth(date: Date): Date;
    getDateInfo(date: any): DateInfo;
    daysInMonth(year: number, month: number): number;
    getMoment(date?: Date): any;
    stringToMoment(str: string, format: string): any;
    getStrMonthName(date: Date): string;
    parse(payload: {
        year: number;
        month: number;
        day: number;
        hour: string;
        minutes: string;
    }): any;
    getDateString(date: Date, showDate: boolean, showTime: boolean): string;
    getDateTimeString(date: Date): string;
    weekdaysMin(): string[];
    weekDays(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DateMiladiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateMiladiService>;
}

declare class DateShamsiService extends DateService {
    protected locale: string;
    constructor();
    getTimes(date: string | Date): string;
    weeksCount(momentObj: any): number;
    subtractMonth(momentOfDate: any, value: number): Date;
    addMonth(momentOfDate: any, value: number): Date;
    to(date1: Date, date2: Date): string;
    from(date1: Date, date2: Date): string;
    isSame(date1: Date, date2: Date, mode: 'year' | 'month' | 'day'): boolean;
    strDate(date: Date): string;
    weekdaysMin(): Array<string>;
    weekDays(): Array<string>;
    toText(): string;
    date(date: Date): any;
    endOfMonth(date: Date): Date;
    startOfMonth(date: Date): Date;
    monthNames(): string[];
    getDateInfo(date: any): DateInfo;
    daysInMonth(year: number, month: number): number;
    getMoment(date?: Date): any;
    stringToMoment(str: string, format: string): any;
    getStrMonthName(date: Date): string;
    getDateTimeString(date: Date): string;
    format(value: Date, format: string): string;
    convertFormatToJalali(format: string): string;
    getShortDateString(date: Date): string;
    getDateString(date: Date, showDate: boolean, showTime: boolean): string;
    parse(payload: {
        year: number;
        month: number;
        day: number;
        hour: string;
        minutes: string;
    }): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateShamsiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateShamsiService>;
}

interface ShortCutData extends MetaobjectDataModel {
    [key: string]: any;
    DynamicCommand: MetaobjectDataModel;
}
type ShortCuts = {
    [key: string]: ShortCutData;
};
type UlvParamType = {
    Flags: {
        Data: string;
        Extra: string;
        Search: string;
        View: string;
    };
    ReportName: string;
    ReportId?: string;
    UsageEnum: string;
};
declare class GeneralControlInfoModel {
    [key: string]: any;
    ControlFieldCaption: string;
    ControlFieldCaptionTranslated: string;
    ControlFieldDefId: string;
    ControlName: string;
    RelatedFieldList: [];
    Hide: boolean;
    xtype: string;
    LabelPosition: string;
    IsMandatory: boolean;
    IsVisible: boolean;
    ShowLabel: boolean;
    IsReadOnly: boolean;
    IsEnabled: boolean;
    IsBold: boolean;
    IsAutomatic: boolean;
    JsonExtraProp: any | null;
    Component: string;
    Info: ControlInfoTypes;
    FieldIcon: string;
    IsLtr: boolean;
    DisplayType: string;
}
interface FileAttachmentInfo {
    [key: string]: any;
    Id: string;
    IsNew: boolean;
    IsDeleted: boolean;
    Type: string;
    FileName?: string;
}
declare class StringControlInfoModel extends GeneralControlInfoModel {
    MaxLength: number;
    MinLength: number;
    RegularExpression: string;
    IsPassword: boolean;
    IsMultiLine: boolean;
    NullText: string;
    AllowedStringChars: string;
    OnlyAcceptCurrentCulture: boolean;
}
declare class RichStringControlInfoModel extends StringControlInfoModel {
    IsHtmlViewer: boolean;
}
declare class NumberControlInfoModel extends GeneralControlInfoModel {
    MinValue: number;
    MaxValue: number;
    DecimalPrecision: number;
    ShowThousandSeperator: boolean;
    NumberType: string;
    CurrencySymbol: string;
}
declare class FilePictureInfoModel extends GeneralControlInfoModel {
    Ext: string;
    FileId: string;
    IsDeleted: boolean;
}
declare class FileControlInfoModel extends GeneralControlInfoModel {
    CanDelete: boolean;
    CanSave: boolean;
    CanView: boolean;
    IsMultiSelect: boolean;
    MaxFileCount: number;
    MaxFileSizeKb: number;
    OfficeOnline: boolean;
    ValidExtensions: string;
    ViewType: string;
}
declare class CommandControlInfoModel extends GeneralControlInfoModel {
    MenuName: string;
    DisableWhenReadonly: boolean;
    DisplayType: string;
    DynamicCommand: string;
}
declare class IconControlInfoModel extends GeneralControlInfoModel {
}
declare class PictureFileControlInfoModel extends GeneralControlInfoModel {
    SizeMode: number;
    MaxFileSizeKb: number;
    ValidExtensions: string;
}
declare class GaugeControlInfoModel extends GeneralControlInfoModel {
    IsAutomatic: boolean;
    MaxValue: number;
    MaxValue2: number;
    MinValue: number;
    MinValue2: number;
    Value: number;
}
type RelationListTypes = RelationListControlInfoModel | HistoryControlInfoModel | RabetehAkseTakiListiControlInfoModel | SingleRelationControlInfoModel;
declare class RelationListControlInfoModel extends GeneralControlInfoModel {
    RelationViewType: string;
    UlvSetting: ReportModel;
}
declare class HistoryControlInfoModel extends RelationListControlInfoModel {
    HasExternalParameter: boolean;
    ParamName1: string;
}
declare class RabetehAkseTakiListiControlInfoModel extends RelationListControlInfoModel {
    AutoSave: any;
}
declare class RelatedReportControlInfoModel extends GeneralControlInfoModel {
    HasExternalParameter: boolean;
    ParamName1: string;
    UlvSetting: ReportModel;
}
declare class CodeEditorControlInfoModel extends GeneralControlInfoModel {
    ExtraText: string;
    Suggestions: string;
}
declare class EnumControlInfoModel extends GeneralControlInfoModel {
    IsMultiSelect: boolean;
    ShowAsRadioButton: boolean;
    IconDisplayType: string;
    DataSource: {
        Rows: RowDataOption[];
    };
    EmptyRowData: RowDataOption;
}
declare class RowDataOption {
    id: string;
    IsEmpty: boolean;
    txt: string;
    txt_safe?: string;
    url: string;
}
declare class DateTimeControlInfoModel extends GeneralControlInfoModel {
    CalendarType: string;
    DateFormat: string;
    ShowDate1: boolean;
    ShowTime1: boolean;
    TimeFormat: string;
}
declare class BoolControlInfoModel extends GeneralControlInfoModel {
    FalseCaption: string;
    TrueCaption: string;
    TrueIcon: string;
    ViewType: string;
    FalseIcon: string;
}
declare class CalculateControlInfoModel extends GeneralControlInfoModel {
    InnerCtrlr: ControlInfoTypes;
    ExecutaionTime: string;
    EditType: string;
    DontShowRecalculateButton: boolean;
}
declare class SubformControlInfoModel extends GeneralControlInfoModel {
    TypeDefId: any;
    TypeDefIcon: string;
    IsComposedRelation: string;
    DropDownReportId: string;
    TypeViewId: string;
    FormPanelSetting: FormSetting;
}
interface DownloadFileInfo {
    fileId: string;
    fileUrl: string;
    viewInBrowser: boolean;
    convertTo: string;
    isOfficeOnline: boolean;
    forOcx: boolean;
}
interface DownloadFileInfoResult {
    filename: string;
    content: string;
    contentType: string;
    succeed: boolean;
}
declare class LinearListControlInfoModel extends GeneralControlInfoModel {
    DefaultField: string;
    ExtraJsonPropField: string;
    FillBeforeDropDown: boolean;
    IsGeneralInfo: boolean;
    IsMultiSelect: boolean;
    Relation: ListRelationModel;
    RelationViewType: string;
    RowIcon: string;
    TargetTypeDefId: string;
}
declare class ListRelationModel {
    [key: string]: any;
    ChildFdId: string;
    ChildFdName: string;
    IsAutoSave: boolean;
    ParentMoId: string;
    RelationType: string;
}
declare class SingleRelationControlInfoModel extends GeneralControlInfoModel {
    ColumnRequestEnum: string;
    DropDownReportId: string;
    FillBeforeDropDown: boolean;
    HideCombo: boolean;
    RelationViewType: string;
    PassParentForm: boolean;
    ShowNewButton: boolean;
    ShowOkCancel: boolean;
    ViewRelatedFormType: string;
    TargetTypeDefId: string;
    DataSource: {
        Rows: RowDataOption[];
    };
    PreviewFieldCaption: string;
    PreviewFieldId: string;
    PreviewFieldName: string;
}
type ControlInfoTypes = SubformControlInfoModel | CalculateControlInfoModel | BoolControlInfoModel | EnumControlInfoModel | IconControlInfoModel | FileControlInfoModel | DateTimeControlInfoModel | NumberControlInfoModel | StringControlInfoModel | PictureFileControlInfoModel | GaugeControlInfoModel | CommandControlInfoModel | CodeEditorControlInfoModel;
interface FormViewSetting {
    [key: string]: any;
    Layout94: any;
    ControlInfo: GeneralControlInfoModel[];
}
interface FormSetting {
    [key: string]: any;
    Data: {
        [key: string]: any;
        Mo: MetaobjectDataModel;
    };
    View: FormViewSetting;
}
declare class MetaobjectDataModel {
    [key: string]: any;
    $FieldDict?: {
        [key: string]: string;
    };
    $ReportId?: string;
    $Type?: string;
    $StyleIndex?: number[];
    $Caption: string;
    $Icon?: string;
    $State?: string;
    $TypeDefId?: string;
    $TypeDefName?: string;
    $Children?: MetaobjectDataModel[];
    Inheritance?: MetaobjectDataModel;
    InheritanceInfo?: {
        ChildFieldName: string;
        ParentFieldName: string;
    };
    Id: string;
}
declare class CalendarMetaobjectDataModel extends MetaobjectDataModel {
    $Color: string;
    $MomentStartDate: string;
    $MomentEndDate: string;
    $StartTimes: string;
    $EndTimes: string;
    $Title: string;
    $Notes: string;
    $StartDateInfo?: DateInfo;
    $EndDateInfo?: DateInfo;
}
declare abstract class MoForReportModelBase<T extends MetaobjectDataModel> {
    $Type?: string;
    TypeDefId: string;
    ReportId: string;
    Icon?: string;
    MoDataList: Array<T>;
    DeletedList: Array<{
        Id: string;
        TypeDefId: string;
    }>;
    AddedList: Array<{
        Id: string;
        TypeDefId: string;
    }>;
    Paging: PagingSetting;
    Relation?: {
        RelationType: string;
        ParentMoId: string;
        ParentFdId: string;
        ChildFdId: string;
        ParentFdName: string;
        ChildFdName: string;
        PassParentMoField: string;
        IsAutoSave: boolean;
        IsAutoSave_ReloadParentForms: boolean;
        IsAutoSave_ReloadRootParentList: boolean;
    };
}
declare class MoForReportModel extends MoForReportModelBase<MetaobjectDataModel> {
    constructor();
}
declare class ReportBaseInfo {
    Id: string;
    Caption: string;
    FolderId: string;
    IconUrl: string;
    Name: string;
    ReportId: string;
}
declare class ReportExtraInfo extends ReportBaseInfo {
    TypeDefId: string;
    TypeDefCaption: string;
    ReportType: string;
    HideToolbar: boolean;
}
declare class MetaobjectRelationModel extends ListRelationModel {
    ParentFdId: string;
    PassParentMoField: string;
}
declare enum FieldInfoTypeEnum {
    IntInfo = 0,
    StringInfo = 2,
    DateInfo = 3,
    BoolInfo = 5,
    EnumInfo = 6,
    UserInfo = 7,
    CategoryInfo = 8,
    MetaObjectInfo = 9,
    CommandInfo = 10,// 0x0000000A
    PicturesInfo = 11,// 0x0000000B
    RelationInfo = 12,// 0x0000000C
    HistoryInfo = 13,// 0x0000000D
    RelationInfoReverse_AksListi = 14,// 0x0000000E
    CreatorUserInfo = 15,// 0x0000000F
    CreationDateInfo = 16,// 0x00000010
    LastUpdateDateInfo = 17,// 0x00000011
    ReminderInfo = 18,// 0x00000012
    RichStringInfo = 19,// 0x00000013
    ConvertCommandInfo = 20,// 0x00000014
    RelationInfoSingleReverse_AksTakiListi = 21,// 0x00000015
    DialCommandInfo = 22,// 0x00000016
    FindContactCommandInfo = 23,// 0x00000017
    SequenceCommandInfo = 24,// 0x00000018
    CurrencyInfo = 25,// 0x00000019
    SinglePictureInfo = 26,// 0x0000001A
    WordReportCommandInfo = 27,// 0x0000001B
    HierarchicalInfo = 28,// 0x0000001C
    TimeSpanInfo = 29,// 0x0000001D
    ReportInfo = 30,// 0x0000001E
    FileInfo = 31,// 0x0000001F
    WordFileInfo = 32,// 0x00000020
    PictureFileInfo = 33,// 0x00000021
    GaugeInfo = 34,// 0x00000022
    CodeInfo = 35,// 0x00000023
    WorkCenterInfo = 36,// 0x00000024
    IsDeletedInfo = 37,// 0x00000025
    RowNumberInfo = 38,// 0x00000026
    BinaryInfo = 39,// 0x00000027
    ReverseMetaObjectInfo_AksTakiTaki = 40,// 0x00000028
    ColorInfo = 41,// 0x00000029
    IconInfo = 42,// 0x0000002A
    RefreshFieldCommandInfo = 43,// 0x0000002B
    ReferenceFieldInfo = 44,// 0x0000002C
    SearchCommandInfo = 45,// 0x0000002D
    OrderInfo = 46
}
interface ClassNamesModel {
    CommandBarClass: string;
    DataClass: string;
    SelectionClass: string;
    ViewerClass: string;
}
interface ExtraModel {
    CustomCommands?: CustomCommand[];
    DefaultCommandsAccess?: DefaultCommandsAccess;
    ParentUlvConfig?: any;
    Relation?: MetaobjectRelationModel;
    Report?: ReportExtraInfo;
    ExtraJsonPropReport?: any;
}
declare class BaseReportModel {
    ClassNames: ClassNamesModel;
    Extra: ExtraModel;
    View: ViewTypes;
    SearchPanel: any;
    DefaultItemComponent: string;
}
interface DefaultCommandsAccess {
    Add: boolean;
    AddToList: boolean;
    Delete: boolean;
    Edit: boolean;
    Export: boolean;
    Print: boolean;
    Refresh: boolean;
    RemoveFromList: boolean;
    View: boolean;
}
declare class CustomCommand {
    Data: any;
    DisableWhenReadonly: boolean;
    HideDisable: boolean;
    IconUrl: string;
    IsLarge: boolean;
    Mytype: string;
    Order: number;
    ShowOnContext: boolean;
    ShowOnToolbar: boolean;
    Text: string;
    UseAlways: boolean;
    UseForMulti: boolean;
    UseForSingle: boolean;
}
declare class ReportModel extends BaseReportModel {
    Data: MoForReportModel;
    constructor();
}
declare class ReportListModel extends BaseReportModel {
    View: GridView;
}
declare class ReportFormModel extends BaseReportModel {
    View: FormView;
}
interface TreeView {
    ConditionalFormats: [];
    ParentIdDbName: string;
    ShowSelectionChecks: boolean;
    TreeAutoOpenLevels: number;
}
interface GridView {
    AllowGridColumnSort: boolean;
    AutoInlineEdit: boolean;
    ColumnRequestEnum: string;
    Columns: Array<ReportViewColumn>;
    ConditionalFormats: [];
    DisableRowReload: boolean;
    GridSetting: GridSetting;
    Grid_FreeColumnSizing: boolean;
    Grid_GridLines: string;
    Grid_HideHeader: boolean;
    Grid_ShowRowNumber: boolean;
    HasConditionalFormat: boolean;
    HasSummaryRow: boolean;
    HideIcon: boolean;
    IsCheckList: boolean;
}
interface CalendarView {
    CalendarFields: CalendarFields;
}
interface FormView {
    FormPanelSetting: any;
}
type ViewTypes = GridView | CalendarView | TreeView | FormView;
type ReportModelTypes = ReportListModel | ReportCalendarModel | ReportFormModel | ReportTreeModel;
declare class ReportCalendarModel extends BaseReportModel {
    View: CalendarView;
}
declare class ReportTreeModel extends BaseReportModel {
    View: TreeView;
}
interface CalendarFields {
    EndDate: string;
    Notes: string;
    StartDate: string;
    Title: string;
    Color: string;
}
declare class ReportViewColumn {
    Alias: string;
    Caption: string;
    FieldDefId: string;
    FieldTypeId: number | string;
    FieldType: string;
    HasSummary: boolean;
    Hidden: boolean;
    IsLtr: boolean;
    IsPreview: boolean;
    MetaFieldTypeId: string;
    Name: string;
    Width: number;
    Tag?: string;
    Icon: string;
    OnlyImage?: boolean;
    Extra?: any;
    $ContentWidth?: string;
    $Width?: string;
    $ColumnWidthNum?: number;
    $ColumnWidth?: string;
    $FitContainerWidth?: string;
    $MergedFieldsToColumn?: string[];
    $CSSClassName?: string;
    $CustomComponent?: EjrayOlgo;
    $TextWidth?: number;
    $IsImageOricon?: boolean;
}
declare class GridSetting {
    ColSettingList: Array<ColSetting>;
    SortSettingList: Array<SortSetting>;
    AutoSizeColumns: boolean;
}
declare class ColSetting {
    Name: string;
    Width: number;
    IsHidden: boolean;
}
declare class SortSetting {
    Name: string;
    SortDirection: string;
    IsGrouped: boolean;
}
declare class ReportField {
    column: ReportViewColumn;
    item: any;
    key: string;
    value: string;
    caption: string;
    constructor(column: ReportViewColumn, item: any);
}
interface LoginResult {
    data: {
        sth: string;
    };
}
interface ComponentSettingsDataModel extends MetaobjectDataModel {
    PlaceHolders?: PlaceHolderDataModel[];
}
interface ComponentDataModel extends MetaobjectDataModel {
    Selector: string;
    Settings: ComponentSettingsDataModel;
}
interface PlaceHolderDataModel extends MetaobjectDataModel {
    Name: string;
    Title: string;
    IsPage: boolean;
    OrderNumber: string;
}
interface ModuleDataModel extends MetaobjectDataModel {
    Title: string;
    PlaceHolder: PlaceHolderDataModel;
    Component: ComponentDataModel;
}
interface PageListReportModel extends MoForReportModel {
    MoDataList: Array<PageDataModel>;
}
interface ModuleListReportModel extends MoForReportModel {
    MoDataList: Array<ModuleDataModel>;
}
interface PageDataModel extends MetaobjectDataModel {
    Component: ComponentDataModel;
    ModuleList: ModuleListReportModel;
    ChildPageList: PageListReportModel;
    ChildPageList2: PageListReportModel;
    Title: string;
    IconName: string;
    IconFontName: any;
    RoutePath: string;
    Route: string;
    IsDefaultRoute: string;
    IsLoginRoute: string;
    ComponentName: string;
    ComponentSelector: string;
}
interface PortalDataModel extends PageDataModel {
    IsActive: boolean;
    IsPwa: boolean;
    PortalSettings: MetaobjectDataModel;
}
interface GroupVisibility {
    enable: boolean;
    visible: boolean;
    readonly: boolean;
}
interface IHeaderLayout {
    [key: string]: any;
    Title: string;
    Subtitle: string;
    Avatar: any;
    FacetList: {
        MoDataList: MetaobjectDataModel[];
    };
}
interface MenuItem {
    icon: string;
    text: string;
    itemId: string;
    Data: any;
    Command: any;
    handler: () => void;
    IsBuiltin?: boolean;
    menu?: {
        items: MenuItem[];
    };
}
interface PagingSetting {
    EndIndex: number;
    HasPaging: boolean;
    Page: number;
    PageSize: number;
    RowCount: number;
    StartIndex: number;
    TotalPages: number;
    TotalRows: number;
}
interface ColumnInfoType {
    Name: string;
    Hidden: boolean;
    Caption: string;
    IsMandatory?: boolean;
    Width: number;
}
interface SearchPanelSettings extends MetaobjectDataModel {
    Title: string;
    ReportId: string;
    IsDefault: boolean;
    IsPublic: boolean;
    ApplyAutomatically: boolean;
    SearchMo?: string;
    FieldsSetting?: string;
}
declare type DeviceSize = 'desktop' | 'mobile' | 'tablet';
declare const DateRanges: string[];
interface UiReportViewBase {
    UiComponent: {
        Component: boolean;
        Module: string;
        ModuleFileName: string;
        Name: string;
        Selector: string;
        Settings: UiReportViewBaseSetting;
    };
}
interface UiReportViewBaseSetting {
    [key: string]: any;
    Type: string;
    Icon: string;
    IsDefault: boolean;
    Hidden: boolean;
    EnableSearch: boolean;
    DisableResponsive?: boolean;
    DisableOverflowContextMenu?: boolean;
    HorizontalGroupBy: boolean;
    BackgroundImage: FileAttachmentInfo;
    BackgroundColor: string;
}
interface LayoutSetting {
    [key: string]: any;
    Title?: string;
    xtype: string;
    TextVisible?: boolean;
    items: LayoutSetting[];
    IsRoot?: boolean;
    SelectedTabPageName?: string;
}
declare type AbbrevationDeviceSize = 's' | 'm' | 'l' | 'xl';
declare type CardMediaSize = '32x32' | '64x64' | '128x128' | '256x256';
interface TreeNodeObj {
    isExpand: boolean;
    visibility: boolean;
    expand: () => void;
    collapse: () => void;
    Data: MetaobjectDataModel;
    children: TreeNodeObj[];
    icon: string;
    key: string;
    leaf: boolean;
    text: string;
    level: number;
    loading?: boolean;
    hasOneDepthLevel?: boolean;
    parentNode: TreeNodeObj | null;
    firstChild: TreeNodeObj | null;
    lastChild: TreeNodeObj | null;
    previousSibling: TreeNodeObj | null;
    nextSibling: TreeNodeObj | null;
    attributes: {
        Data: MetaobjectDataModel | null;
    };
    hasChildNodes: () => boolean;
    noDrop: boolean;
    $Children?: TreeNodeObj[];
}
interface ColumnResizedArgs {
    name: string;
    width: number;
    thDom: HTMLTableCellElement;
}
type columnsResizedEventArgs = {
    columns: Array<ReportViewColumn>;
    resized: Array<ColumnResizedArgs>;
};
type RelationItemType = {
    Id: string;
    SourceTypeDefId: string;
    ObjectInRelationName: string;
    GroupCaption: string;
};
interface EjrayOlgo extends MetaobjectDataModel {
    Module: string;
    ModuleFileName: string;
    Name: string;
    Selector: string;
    Parameters?: MetaobjectDataModel;
    Settings?: MetaobjectDataModel;
}
interface IUploadingState {
    key: string;
    uploading: boolean;
    state: 'Uploading' | 'Error' | 'Complete' | 'Start';
    progress: any;
}
type GroupByItem = {
    [key: string]: any;
    id: string;
    key: string;
    value: any[];
};
type NotifyOptions = {
    Sound: boolean;
    Image: string | null;
    Title: string | null;
    Icon: boolean;
    Delay: number;
    Closable: boolean;
    DelayIndicator: boolean;
    CloseOnClick: boolean;
    IsRtl: boolean;
    Position: string | object;
    SoundPath: string;
    Size: string;
    ContinueDelayOnInactiveTab: boolean;
    Width: number;
    MessageHeight: number;
    NotificationItem?: NotificationItem;
};
type ShareButtonsChoiceDef = {
    formPanelCtrlr: any;
    mo: MetaobjectDataModel;
    choiceList: ChoiceDef[];
    add: boolean;
};
type ChoiceDef = {
    ActivityDefId: string;
    ActivityRunId: string;
    ChoiceDefId: string;
    ChoiceName?: string;
    Title: string;
    Icon?: string;
    HasBar?: boolean;
};
type WorkflowExecuteChoiceStatus = {
    loading: boolean;
    result: any;
    error: any;
    choice?: ChoiceDef;
};
type NotificationPayload = {
    msg: string;
    title: string;
    type: string;
    image: string;
    mo: any;
    uiOptions: NotifyOptions;
    otherOptions: Record<string, any>;
};
type NotificationAction = {
    Title: string;
    Id: string;
    Icon: string;
    Status: string | any;
};
type NotificationItem = MetaobjectDataModel & {
    Title: string;
    Unread: boolean;
    Content: string;
    $SafeContent?: SafeHtml;
    Priority: number;
    Subject: string;
    Tag: string;
    Icon: string;
    Image: string;
    CreationDate: Date;
    CreationDate$Caption: string;
    UiActions?: NotificationAction[];
    $ChoiceDefStatus?: WorkflowExecuteChoiceStatus;
};
type ExNotificationPayload = {
    lang: string;
    isRtl: boolean;
    notificationItem: NotificationItem;
};
type FormVisibilityStatus = 'Pending' | 'Visible';
type CartableTemplateKey = {
    TypeDefId: string;
    SettingsId: string;
};
declare enum SortDirection {
    NONE = "none",
    ASC = "asc",
    DESC = "desc"
}
interface CollectionSort {
    field: string | null;
    direction: SortDirection;
    isNumber?: boolean;
}
interface SearchInput {
    text: string;
    category: string | null;
}
interface CollectionGroup {
    field: string;
    direction: SortDirection;
    showAsColumn: boolean;
}
interface CollectionPage {
    pageSize: number;
    currentPage: number;
}
interface CollectionState {
    sortBy: CollectionSort[];
    groupBy: CollectionGroup[];
    page: CollectionPage;
    searchInput: SearchInput;
}
interface TableState extends CollectionState {
    columns: string[];
    columnKeys: string[];
    freezeToColumn: string | null;
}
declare enum SelectionMode {
    SINGLE = "single",
    MULTIPLE = "multiple",
    NONE = "none"
}
interface TypeUlvMainCtrlr {
    Adapter: any;
    Setting: any;
    System: any;
    UlvParams: any;
    Features: any;
    UiOverride: any;
    SearchPanelCtrlr: any;
    SelectionAdapter: any;
    DataCtrlr: TypeUlvDataCtrlr;
    CommandBarCtrlr: any;
    ViewerAdapter: any;
    ParentMo: any;
    FieldCtrlr: any;
    isMandatory: boolean;
    IsPreviewSourceField: boolean;
    ShowOkCancelButtons: boolean;
    _isEnable: boolean;
    _isReadOnly: boolean;
    _isVisible: boolean;
    FootterButtons: boolean;
    RefreshRowsByMosNoSelectionChange(edidedMos: MetaobjectDataModel[], addedMos: MetaobjectDataModel[], deletedMos: MetaobjectDataModel[]): void;
    RefreshRowsByMos(edidedMos: MetaobjectDataModel[], addedMos: MetaobjectDataModel[], deletedMos: MetaobjectDataModel[]): void;
}
interface TypeUlvDataCtrlr {
    GetEditFormParams(mo: any, isReadOnly: any, isNew: any, inheritanceChildTypeDef: any, doReturn: any): Record<string, any>;
}
interface FormComponentParams {
    formSetting?: FormSetting;
    moId: string;
    typeDefId: string | undefined;
    reportId?: string;
    viewId?: string | undefined;
    ViewName?: string | undefined;
    inDialog?: boolean;
    isSimple?: boolean;
    loadActivityView?: boolean;
}
interface BruleActionMessage {
    MessageType: number;
    EscapeCharacters: boolean;
    MessageExpression: string;
    MessageExpressionHtml: SafeHtml;
}
type ColumnSummaryType = {
    moArr: MetaobjectDataModel[];
    column: ReportViewColumn;
    groupName: string;
    groupLevel: number;
    summaryFn: (val: any) => void;
};
interface ContainerReportSetting {
    RelatedReport: MetaobjectDataModel;
    RowClick: string;
    DataOnly: boolean;
    IsReportPage?: boolean;
}
type CssBackground = {
    color: string;
    url: string;
    repeat: boolean;
};
interface UiResponsiveSettings {
    IsActive: boolean;
    XxlColumns: number;
    XlColumns: number;
    LColumns: number;
    MdColumns: number;
    SmColumns: number;
}
type CultureTypes = 'fa-IR' | 'ar-AE' | 'en-US';
interface ISystemData {
    Id: string;
    Name: string;
    Caption: string;
    IconName: string;
    RootFolderId: string;
    IsLoaded: boolean;
    IsUiCreated: boolean;
    IsActive: boolean;
    CustomCodeList: any;
    OnlyCode: boolean;
    NoUi: boolean;
    HasVerifyPassword: boolean;
    ExtraData: any;
    Navigator: Navigator;
    Modules: Modules;
    ShowRibbon: boolean;
    JsonExtraProp: Record<string, any>;
    CommandGroups: CommandGroup[];
    WorkflowList: WorkflowItem[];
    UseTreeNavigator: boolean;
}
type WorkflowItem = {
    Id: string;
    Caption: string;
    Name: string;
};
interface CommandGroup {
    Caption: string;
    Name: string;
    Key: string;
    Order: number;
    Commands: Command[];
}
interface Command {
    Caption: string;
    Name: string;
    Key: string;
    Size: string;
    CommandId: string;
    DynamicCommand?: MetaobjectDataModel;
    IconSize: number;
    Alignment: string;
    Icon: string;
    Menu: Command[];
    IsGlobal: boolean;
    Order?: number;
}
interface Navigator {
    Root: NavigatorRoot;
    Width: number;
}
interface NavigatorRoot {
    IsRoot: boolean;
    IsTab: boolean;
    Id: string;
    FolderId: string;
    ReportId: string;
    Name: string;
    Caption: string;
    ReportCountExtension: boolean;
    NotLoaded: boolean;
    IconUrl: string;
    Items: NavigatorRootItem[];
}
interface NavigatorRootItem {
    IsRoot: boolean;
    IsTab: boolean;
    Id: string;
    FolderId: string;
    ReportId: string;
    Name: string;
    Caption: string;
    ReportCountExtension: boolean;
    NotLoaded: boolean;
    IconUrl: string;
    Items: NavigatorFolder[];
}
interface NavigatorFolder {
    IsRoot: boolean;
    IsTab: boolean;
    Id: string;
    FolderId: string;
    ReportId: string;
    Name: string;
    Caption: string;
    ReportCountExtension: boolean;
    NotLoaded: boolean;
    IconUrl: string;
    Items: NavigatorFolderItem[];
    FolderJsonExtraProp?: Record<string, any>;
}
interface NavigatorFolderItem {
    IsRoot: boolean;
    IsTab: boolean;
    Id: string;
    FolderId: string;
    ReportId: string;
    Name: string;
    Caption: string;
    ReportCountExtension: boolean;
    NotLoaded: boolean;
    ShowReportInNavigator?: boolean;
    InsideView_Height?: number;
    InsideView_RelatedFieldName?: string;
    InsideView_RelatedFieldId?: string;
    InsideView_ReportName?: string;
    IconUrl?: string;
    DynamicCommand?: MetaobjectDataModel;
}
interface Modules {
    GetListMethod: string;
    AddToFavoriteMethod: string;
    RemoveFromFavoriteMethod: string;
}
interface ISystem {
    Caption: string;
    Id: string;
    Name: string;
    SystemData: ISystemData;
}
type CommonObservable = {
    on: (args: any) => void;
    events: Record<string, any>;
    fireEvent: (...args: any[]) => void;
};
type NavGroupItem = {
    icon: string;
    id: string;
    isDynCommand: boolean;
    leaf: boolean;
    text: string;
    data: NavGroupItemData;
    routeId: string;
};
type NavGroupItemData = {
    Caption: string;
    FolderId: string;
    IconUrl: string;
    Id: string;
    IsRoot: boolean;
    IsTab: boolean;
    Name: string;
    NotLoaded: boolean;
    DynamicCommand: MetaobjectDataModel;
    ReportCountExtension: boolean;
    ReportId: string;
    fontIcon: string;
    fontName: any;
    ShowReportInNavigator: boolean;
    InsideView_Height: number;
    InsideView_RelatedFieldId: string;
    InsideView_RelatedFieldName: string;
    InsideView_ReportName: string;
};
type CustomNavGroupUi = CommonObservable & {
    cls: string;
    Data: NavGroupItemData;
    icon: string;
    fontIcon: string;
    fontName: any;
    id: string;
    isDynCommand: boolean;
    leaf: boolean;
    text: string;
    root: {
        children: NavGroupItem[];
    };
    ulvUi: any;
    _onBeforeClick: (data: any) => void;
};
type CustomNavPageUi = CommonObservable & {
    Data: NavGroupItemData;
    JsonExtraProp: Record<string, any>;
    cls: string;
    controlItems: Array<CustomNavGroupUi>;
    events: Record<string, any>;
    itemId: string;
    title: string;
    selected: boolean;
    icon: string;
};
type CustomSystemNavUi = CommonObservable & {
    itemId: string;
    title: string;
    FastSearchNavItemList: Array<any>;
    JsonExtraProp: Record<string, any>;
    SystemData: ISystemData;
    childControl: {
        controlItems: Array<CustomNavPageUi>;
    };
};
type CustomSystemContainerUi = CommonObservable & {
    SystemData: ISystemData;
};
type CustomSystemUi = CommonObservable & {
    SystemNavUi: CustomSystemNavUi;
    SystemData: ISystemData;
    SystemContainerUi: CustomSystemContainerUi;
    Ribbon: CustomRibbon;
};
type CustomApplicationUi = CommonObservable & {
    _selectedSystemId: string;
    _systemsUi: Array<CustomSystemUi>;
    _appMenuBody: CustomApplicationMenuBodyUi;
};
type CustomApplicationMenuBodyUi = CommonObservable & {
    SystemDataDict: Record<string, ISystemData>;
    items: Array<AppMenu>;
};
type CustomRibbon = CommonObservable;
type AppMenu = {
    id: string;
    title: string;
    subtitle?: string;
    callback?: (event: MouseEvent) => void;
    icon?: string;
    iconImage?: string;
    font?: string;
    selected?: boolean;
    disabledDragAndDrop?: boolean;
    stickToPosition?: boolean;
    SystemData: ISystemData;
};
type ShellbarSetting = MetaobjectDataModel & {
    CssStyles: string;
    subtitle: string;
    calcSubtitle: string;
    logo: FilePictureInfoModel;
    ProductSwitchItems: MoForReportModel;
    ProductMenuItems: MoForReportModel;
    UserMenuItems: MoForReportModel;
    ActionItems: MoForReportModel;
    SidebarReport: MetaobjectDataModel;
    ProfileImageReport: MetaobjectDataModel;
};
type InfoBarType = {
    id: string;
    text: string;
    type: any;
    buttons: Array<string>;
    handler?: (x: any) => void;
    icon: string;
};
interface AppTileGroup extends MetaobjectDataModel {
    Title: string;
    Visible: boolean;
    Visible$Caption: string;
    Locked: boolean;
    Locked$Caption: string;
    OrderNumber: string;
    OrderNumber$Caption: string;
    Predefined: boolean;
    Predefined$Caption: string;
    TileGroupType: string;
    TileGroupType$Caption: string;
    CssStyles: string;
    ItemCount2XL: string;
    ItemCount2XL$Caption: string;
    ItemCountXL: string;
    ItemCountXL$Caption: string;
    ItemCountL: string;
    ItemCountL$Caption: string;
    ItemCountMD: string;
    ItemCountMD$Caption: string;
    ItemCountSM: string;
    ItemCountSM$Caption: string;
    HideHeader: boolean;
    HideHeader$Caption: string;
    BackgroundColor: string;
    IconFont: string;
    IconFontName: any;
    Icon: string;
    IconImage: FilePictureInfoModel;
    RoutePath: string;
    $TypeDefCaption: string;
    $HasChildren: boolean;
    $Children: AppTileGroup[];
    $TileSettingChanged: boolean;
    $Disabledpin: boolean;
    navigatorTitle: string;
    navigatorVisible: boolean;
    navigatorTiles: MetaobjectDataModel[];
    navigatorActionLinks: any[];
    $TilesLoaded: boolean;
    AppTiles: MoForReportModelBase<AppTile>;
}
interface AppTile extends MetaobjectDataModel {
    Visible: boolean;
    Visible$Caption: string;
    Locked: boolean;
    Locked$Caption: string;
    OrderNumber: string;
    OrderNumber$Caption: string;
    IsActionLink: boolean;
    IsActionLink$Caption: string;
    AppTileGroup: MetaobjectDataModel;
    A_App_Component: EjrayOlgo;
    A_App_DynamicCommand: MetaobjectDataModel;
    A_App_AppKey: string;
    Predefined: boolean;
    Predefined$Caption: string;
    App: MetaobjectDataModel;
    Component: MetaobjectDataModel;
    DynamicCommand: MetaobjectDataModel;
    TileTitle: any;
    Subtitle: any;
}

declare class MoReportValuePipe implements PipeTransform {
    transform(name: string, mo: MetaobjectDataModel, Columns?: {
        [key: string]: any;
        Name: string;
        Caption: string;
    }[], caption?: boolean): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoReportValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoReportValuePipe, "rval", false>;
}

declare class NumeralPipe implements PipeTransform {
    transform(value: string | number, decimalPrecision: number, showThousandSeperator: boolean): string | number;
    _getReturnaValue(newVal: string, decimal: number): string;
    floor(num: any, precision: any): number;
    getValue(value: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumeralPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NumeralPipe, "numeral", false>;
}

declare class GroupByPipe implements PipeTransform {
    resolveValue(current: any, property: string, $Caption?: boolean, dot$Caption?: boolean): any;
    transform(collection: any[], property: string): GroupByItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GroupByPipe, "groupBy", false>;
}

declare class ContextMenuPipe implements PipeTransform {
    private bbbPipe;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    transform(commands: MenuItem[] | null, checkList?: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ContextMenuPipe, "contextMenu", false>;
}

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

declare class SeperatorFixPipe implements PipeTransform {
    transform(buttons: any[], removeSeperator?: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SeperatorFixPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SeperatorFixPipe, "seperatorFix", false>;
}

declare class ConvertToStylePipe implements PipeTransform {
    constructor();
    transform(text: string | undefined): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConvertToStylePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ConvertToStylePipe, "convertToStyle", false>;
}

declare class TlbButtonsPipe implements PipeTransform {
    constructor();
    transform(buttons: any[] | null, property: string | string[], value?: any | any[], hideMoveButtons?: boolean): any[];
    filterBtn(btn: any, property: any, value: any, hideMoveButtons: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TlbButtonsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TlbButtonsPipe, "tlbButtons", false>;
}

declare class RemoveNewlinePipe implements PipeTransform {
    constructor();
    transform(text: string | undefined): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveNewlinePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RemoveNewlinePipe, "removeNewline", false>;
}

declare class MoValuePipe implements PipeTransform {
    constructor();
    transform(name: string, mo: MetaobjectDataModel, caption?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoValuePipe, "val", false>;
}

declare class FilterPipe implements PipeTransform {
    transform(collection: any[], filterArgs: {
        [key: string]: any;
    }): any[];
    matchFilter(value: any, fitlerArgs: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filter", false>;
}

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

declare class MoReportValueConcatPipe implements PipeTransform {
    constructor();
    transform(names: string[], symbol: string, mo: MetaobjectDataModel, Columns?: any[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoReportValueConcatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoReportValueConcatPipe, "rvalConcat", false>;
}

declare class FilterStringPipe implements PipeTransform {
    transform(collection: any[] | undefined | null, filterArgs: {
        [key: string]: any;
        mode: 'contains' | 'equals' | 'startWith' | 'endWith';
    }): any[];
    matchFilter(value: any, filterArgs: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterStringPipe, "filterStr", false>;
}

type SortOrder = 'asc' | 'desc';
declare class SortPipe implements PipeTransform {
    transform(value: any[], sortOrder?: SortOrder | string, sortKey?: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SortPipe, "sort", false>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortPipe>;
}

declare class BbbTranslatePipe implements PipeTransform {
    transform(key: string | null, addText?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbbTranslatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BbbTranslatePipe, "bbbTranslate", false>;
}

declare class BarsaIconDictPipe implements PipeTransform {
    constructor();
    transform(type: string, size?: string): IconFont;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaIconDictPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BarsaIconDictPipe, "barsaIconDict", false>;
}

declare class FileInfoCountPipe implements PipeTransform {
    constructor();
    transform(value: {
        Files: any[];
    }): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileInfoCountPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileInfoCountPipe, "fileinfoCount", false>;
}

declare class ControlUiPipe implements PipeTransform {
    transform(caption: string, layout94: LayoutSetting, columnName?: string): LayoutSetting | null;
    findLayoutItem(caption: any, layoutItem: any, columnName?: string): LayoutSetting | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ControlUiPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ControlUiPipe, "controlUi", false>;
}

declare class VisibleValuePipe implements PipeTransform {
    constructor();
    transform(object: any, field: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibleValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<VisibleValuePipe, "barsaVisibleValue", false>;
}

declare class FilterToolbarControlPipe implements PipeTransform {
    transform(config: LayoutSetting): LayoutSetting[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterToolbarControlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterToolbarControlPipe, "filterToolbarControl", false>;
}

declare enum TableHeaderWidthMode {
    FitToRowContent = 1,
    FitToContainer = 2,
    FreeColumnSize = 3,
    ColumnWidth = 4
}
declare function setTableThWidth(tableHeaderMode: TableHeaderWidthMode, columns: ReportViewColumn[], thList: HTMLTableCellElement[], renderer2: Renderer2): void;
declare function calculateColumnContent(columns: ReportViewColumn[], moDataList: MetaobjectDataModel[]): void;
declare function calculateColumnWidth(container: HTMLElement, columns: ReportViewColumn[], moDataList: MetaobjectDataModel[], disableContextMenuOverflow: boolean, contextMenuItems: MenuItem[]): {
    columns: ReportViewColumn[];
    contextMenuWidth: number;
};
declare function setColumnWidthByMaxMoContentWidth(moDataList: MetaobjectDataModel[], column: ReportViewColumn): void;
declare function calculateMoDataListContentWidthByColumnName(moDataList: MetaobjectDataModel[], column: ReportViewColumn): number;
declare function calculateFreeColumnSize(columns: ReportViewColumn[]): ReportViewColumn[];
declare function calculateColumnWidthFitToContainer(container: HTMLElement, canView: boolean, disableContextMenuOverflow: boolean, contextMenuItems: MenuItem[], columns: ReportViewColumn[]): {
    columns: ReportViewColumn[];
    contextMenuWidth: number;
};
declare function calcContextMenuWidth(contextMenuItems: MenuItem[], disableContextMenuOverflow: boolean): number;
declare function isInLocalMode(): boolean;
declare function getLabelWidth(item: any): number | undefined;
declare function getColumnValueOfMoDataList(name: string, mo: MetaobjectDataModel, Columns?: {
    [key: string]: any;
    Name: string;
    Caption: string;
}[], caption?: boolean): any;
declare function throwIfAlreadyLoaded(parentModule: any, moduleName: string): void;
declare function measureText2(text: string, fontSize?: string, fontName?: string): number;
declare function measureText(text: string, fontSize?: string): number;
declare function measureTextBy(text: string, fontSize?: string, fontName?: string): number;
declare function genrateInlineMoId(): string;
declare function enumValueToStringSize(value: string, defaultValue: string): string;
declare function executeUlvCommandHandler(button: any, options?: any): void;
declare function getUniqueId(parts: number): string;
declare function getDateService(logService: LogService, culture?: CultureTypes): DateService;
declare function getAllItemsPerChildren(item: TreeNodeObj, level: number, array: MetaobjectDataModel[], parentNode: TreeNodeObj, autoOpenLevels: number): any;
declare function setOneDepthLevel(node: any): void;
declare function isFirefox(): boolean;
declare function getImagePath(type: string, moId: string | null, fileId: string, fieldDefId?: string, size?: number, sizeH?: number): string;
declare function isFunction(functionToCheck: any): boolean;
declare function DeviceWidth(): number;
declare function getHeaderValue(fieldValue: any, returnValue?: true): any;
declare function elementInViewport2(el: any): boolean;
declare function PreventDefaulEvent(e: any, propagationDisable?: boolean): void;
declare function stopPropagation(e: any): void;
declare function getParentHeight(elDom: HTMLElement): number;
declare function getComponentDefined(controlUi: {
    originalXtype: string;
}, customUiSetting: {
    Module: string;
    Name: string;
    Selector: string;
}): {
    moduleName: string;
    modulePath: string;
    componentName: string;
    selector: string;
};
declare function isSafari(): boolean;
declare function isFF(): boolean;
declare function getDeviceIsPhone(): boolean;
declare function getDeviceIsDesktop(): boolean;
declare function getDeviceIsTablet(): boolean;
declare function getDeviceIsMobile(): boolean;
declare function getControlSizeMode(el: HTMLElement, deviceSize?: 's' | 'm' | 'l' | 'xl'): AbbrevationDeviceSize;
declare function formatBytes(bytes: any, decimals: number | undefined, size: 'Bytes' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB'): string;
declare function getValidExtension(validExtensions: any): string;
declare function getIcon(type: string): string;
declare function isImage(type: any): boolean;
declare function GetAllColumnsSorted(context: any): Array<ReportViewColumn>;
declare function GetVisibleValue(object: any, field: any): string;
interface Group {
    $Group: any;
    $Level: number;
    $Count: number;
    $Expanded: boolean;
    $Parent: any;
    $Children: any[];
    $Visibility: boolean;
}
declare function GroupBy(collection: any[], sortSettings: SortSetting[]): {
    grouped: Group;
    groups: any[];
};
declare function FindGroup(groupTitle: string, a: any): any;
declare function FillAllLayoutControls(item: LayoutSetting, layoutControls: LayoutSetting[]): void;
declare function FindToolbarItem(toolbarItems: MenuItem[], value: string, prop?: string): MenuItem | null;
declare function FindLayoutSettingFromLayout94(layout94: LayoutSetting, layoutTitle: string): LayoutSetting | null;
declare function GetAllHorizontalFromLayout94(layout94: LayoutSetting): LayoutSetting[];
declare function getGridSettings(context: any): GridSetting;
declare function getResetGridSettings(columns: ReportViewColumn[] | any[], context: any): GridSetting;
declare function GetDefaultMoObjectInfo(typeDefId: string): MetaobjectDataModel;
declare function getLayout94ObjectInfo(): LayoutSetting;
declare function getFormSettings(typeDefId: string): FormSetting;
declare function createFormPanelMetaConditions(typeDefId: string, controlsInfo: GeneralControlInfoModel[], controlName: string, value: any): any;
declare function getNewMoGridEditor(formSettings: FormSetting, typedefId: string): Partial<FormSetting>;
declare function createGridEditorFormPanel(formSettings: FormSetting, mo: MetaobjectDataModel, typedef: string, relation: any, rewriteLayout?: boolean, UlvMainCtrlr?: any): any;
declare function getLayoutControl(controlName: string, controlCaption?: string, hide?: boolean): Partial<GeneralControlInfoModel>;
declare function getControlList(mo: MetaobjectDataModel, controlDbNames: string[], isSearchPanel: boolean, isGridEditor: boolean): Promise<GeneralControlInfoModel[]>;
type NzSafeAny = any;
type NumberInput = number | string | undefined | null;
interface NgStyleInterface {
    [klass: string]: NzSafeAny;
}
interface IndexableObject {
    [key: string]: NzSafeAny;
}
declare function shallowEqual(objA?: IndexableObject, objB?: IndexableObject): boolean;
declare function toNumber(value: number | string): number;
declare function toNumber<D>(value: number | string, fallback: D): number | D;
declare function InputNumber(fallbackValue?: NzSafeAny): NzSafeAny;
declare enum AffixRespondEvents {
    resize = "resize",
    scroll = "scroll",
    touchstart = "touchstart",
    touchmove = "touchmove",
    touchend = "touchend",
    pageshow = "pageshow",
    load = "LOAD"
}
interface SimpleRect {
    top: number;
    left: number;
    width?: number;
    height?: number;
    bottom?: number;
}
declare function isTargetWindow(target: Element | Window): target is Window;
declare function getTargetRect(target: Element | Window): SimpleRect;
declare function getFieldValue(name: string, mo: MetaobjectDataModel, caption?: boolean): string;
declare const availablePrefixes: string[];
declare function requestAnimationFramePolyfill(): typeof requestAnimationFrame;
declare function ExecuteDynamicCommand(command: {
    Id: string;
}, mo?: MetaobjectDataModel | null): void;
declare function ExecuteWorkflowChoiceDef(scope: any, param: any, success: (result: any) => void, failed: (error: any) => void): void;
declare function getRequestAnimationFrame(): typeof requestAnimationFrame;
declare function cancelRequestAnimationFrame(id: number): NzSafeAny;
type EasyingFn = (t: number, b: number, c: number, d: number) => number;
declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;
interface NzScrollToOptions {
    /** Animation duration, default as 450 */
    duration?: number;
    /** Scroll container, default as window */
    easing?: EasyingFn;
    /** Scroll end callback */
    callback?(): void;
}
declare const WordMimeType = ".doc,.docx,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document";
declare const ImageMimeType = ".jpeg,.jpg,.gif,.png,.bmp,.tif,image/*";
declare const PdfMimeType = ".pdf";
declare const AllFilesMimeType = ".txt,.ppt,.pdf,.*";
declare const VideoMimeType = "video/*";
declare const AudioMimeType = "audio/*";
declare function ChangeLayoutInfoCustomUi(layoutInfo: LayoutSetting, componentUi: EjrayOlgo): void;
declare const mobile_regex: RegExp;
declare const number_only: RegExp;
declare function forbiddenValidator(nameRe: RegExp): ValidatorFn;
declare function GetImgTags(setting: any): string;
declare function ImagetoPrint(setting: any): string;
declare function PrintImage(setting: any): void;
declare function SaveImageToFile(name: string, src: string): void;
declare function validateAllFormFields(formGroup: FormGroup): void;
declare function getFocusableTagNames(): string;
declare function addCssVariableToRoot(variableName: string, variableValue: string): void;
declare function flattenTree(root: Record<string, any>, prop: string): Record<string, any>[];
declare function IsDarkMode(): boolean;
declare function nullOrUndefinedString(param: any): string;
declare function fromEntries<K extends string, V>(entries: [K, V][]): Record<K, V>;

declare class MultipleGroupByPipe implements PipeTransform {
    private bbbPipe;
    transform(collection: any[], sortSettings: SortSetting[]): any;
    findGroup(groupTitle: string, a: any): any;
    prepareArr(arr: any, parent: Group | null, item: Group, maxlevel: any, level: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultipleGroupByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MultipleGroupByPipe, "multipleGroupBy", false>;
}

declare class PictureFieldSourcePipe implements PipeTransform {
    constructor();
    transform(value: string | any, type: string, moId: string | null, fieldDefId?: string, sw?: number, sh?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PictureFieldSourcePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PictureFieldSourcePipe, "picFieldSrc", false>;
}

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

declare class CanUploadFilePipe implements PipeTransform {
    constructor();
    transform(fileCount: number | null, maxFileCount?: number, disable?: boolean, readonly?: boolean): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CanUploadFilePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CanUploadFilePipe, "canUploadFile", false>;
}

declare class ListCountPipe implements PipeTransform {
    constructor();
    transform(list: Array<any>): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListCountPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ListCountPipe, "listCount", false>;
}

declare class TotalSummaryPipe implements PipeTransform {
    transform(moDataList: MetaobjectDataModel[], columnName: string): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<TotalSummaryPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TotalSummaryPipe, "totalSummary", false>;
}

declare class MergeFieldsToColumnsPipe implements PipeTransform {
    transform(columns: ReportViewColumn[], mergeColumnMoDataList: MetaobjectDataModel[] | undefined): ReportViewColumn[];
    protected _mergeFieldsToColumns(columns: ReportViewColumn[], mergeColumnMoDataList: MetaobjectDataModel[] | undefined): ReportViewColumn[];
    static ɵfac: i0.ɵɵFactoryDeclaration<MergeFieldsToColumnsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MergeFieldsToColumnsPipe, "mergeFieldsToColumns", false>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MergeFieldsToColumnsPipe>;
}

declare class FindColumnByDbNamePipe implements PipeTransform {
    transform(columns: ReportViewColumn[], name: string, secondaryColumns?: ReportViewColumn[]): ReportViewColumn | undefined;
    private findColumn;
    private _findColumn;
    static ɵfac: i0.ɵɵFactoryDeclaration<FindColumnByDbNamePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FindColumnByDbNamePipe, "findColumnByDbName", false>;
}

declare class FilterColumnsByDetailsPipe implements PipeTransform {
    transform(columns: ReportViewColumn[], detailsColumns: ReportViewColumn[], rowIndicator: boolean): ReportViewColumn[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterColumnsByDetailsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterColumnsByDetailsPipe, "filterColumnsByDetails", false>;
}

declare class MoInfoUlvMoListPipe implements PipeTransform {
    private _moInfoUlvPaging;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    transform(loading: boolean, isDataLoadedFirstTime: boolean, ulvAdapterMoDataList: MetaobjectDataModel[] | undefined, ulvUiMoDataList: MetaobjectDataModel[] | undefined, ulvAdapterPaging: PagingSetting | undefined, ulvUiPaging: PagingSetting | undefined): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoInfoUlvMoListPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoInfoUlvMoListPipe, "moInfoUlvMoList", false>;
}

declare class ReversePipe implements PipeTransform {
    transform(value: any, doReverse?: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ReversePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ReversePipe, "reverse", false>;
}

declare class ColumnCustomUiPipe implements PipeTransform {
    private _findColumnByDbNamePipe;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    transform(column: ReportViewColumn, columnComponents: MoForReportModel | null): EjrayOlgo | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnCustomUiPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnCustomUiPipe, "columnCustomUi", false>;
}

declare class SanitizeTextPipe implements PipeTransform {
    private _domSanitizer;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    transform(text: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeTextPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizeTextPipe, "sanitizeText", false>;
}

declare class MoInfoUlvPagingPipe implements PipeTransform {
    transform(ulvAdapterPaging?: PagingSetting, ulvUiPaging?: PagingSetting): PagingSetting | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoInfoUlvPagingPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MoInfoUlvPagingPipe, "moInfoUlvPaging", false>;
}

declare class ColumnCustomComponentPipe implements PipeTransform {
    transform(columns: ReportViewColumn[], customComponentMoDataList: MetaobjectDataModel[] | undefined): ReportViewColumn[];
    protected _setCustomComponentToColumns(columns: ReportViewColumn[], customComponentMoDataList: MetaobjectDataModel[] | undefined): ReportViewColumn[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnCustomComponentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnCustomComponentPipe, "columnCustomComponent", false>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnCustomComponentPipe>;
}

declare class ColumnValuePipe implements PipeTransform {
    transform(column: ReportViewColumn, mo: MetaobjectDataModel): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnValuePipe, "columnValue", false>;
}

declare class ColumnIconPipe implements PipeTransform {
    transform(column: ReportViewColumn, mo: MetaobjectDataModel): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnIconPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnIconPipe, "columnIcon", false>;
}

declare class RowNumberPipe implements PipeTransform {
    transform(moId: string, setting: PagingSetting, moDataList: MetaobjectDataModel[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RowNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RowNumberPipe, "rowNumber", false>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RowNumberPipe>;
}

declare class ComboRowImagePipe implements PipeTransform {
    transform(value: string, data: any[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboRowImagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ComboRowImagePipe, "comboRowImg", false>;
}

declare class IsExpandedNodePipe implements PipeTransform {
    transform(value: TreeNodeObj): boolean;
    _isExpanded(value: TreeNodeObj | null): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsExpandedNodePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsExpandedNodePipe, "isExpandedNode", false>;
}

declare class ThImageOrIconePipe implements PipeTransform {
    transform(column: ReportViewColumn): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThImageOrIconePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThImageOrIconePipe, "thImageOrIcon", false>;
}

declare class FindPreviewColumnPipe implements PipeTransform {
    transform(columns: ReportViewColumn[]): ReportViewColumn | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<FindPreviewColumnPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FindPreviewColumnPipe, "findPreviewColumn", false>;
}

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

declare class FilterWorkflowInMobilePipe implements PipeTransform {
    constructor();
    transform(buttons: any[], worfklowButtonsOnFooter?: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterWorkflowInMobilePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterWorkflowInMobilePipe, "filterWorkflowInMobile", false>;
}

declare class HideColumnsInmobilePipe implements PipeTransform {
    transform(columns: ReportViewColumn[], hideColumnsInMobile: string): ReportViewColumn[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HideColumnsInmobilePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HideColumnsInmobilePipe, "hideColumnsInmobile", false>;
}

declare class StringToNumberPipe implements PipeTransform {
    transform(val: string): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<StringToNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StringToNumberPipe, "strToNum", false>;
}

declare class ColumnValueOfParametersPipe implements PipeTransform {
    _findColumnByDbName: FindColumnByDbNamePipe;
    _columnValuePipe: ColumnValuePipe;
    _moValuePipe: MoValuePipe;
    transform(allColumns: ReportViewColumn[], mo: MetaobjectDataModel, fieldname: string, defaultValue: any, caption?: boolean): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnValueOfParametersPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnValueOfParametersPipe, "columnValueOfParameters", false>;
}

declare class HideAcceptCancelButtonsPipe implements PipeTransform {
    constructor();
    transform(buttons: any[] | null, hideAcceptCancel: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HideAcceptCancelButtonsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HideAcceptCancelButtonsPipe, "hideAcceptCancel", false>;
}

declare class FilterInlineActionListPipe implements PipeTransform {
    transform(actionList: any[], hideDeleteButton: boolean, hideEditButton: boolean, hideShowButton: boolean): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterInlineActionListPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterInlineActionListPipe, "filterInlineActionList", false>;
}

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

declare class ToolbarSettingsPipe implements PipeTransform {
    transform(toolbarButtons: any[], toolbarSettings: MoForReportModel): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarSettingsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToolbarSettingsPipe, "ulvToolbarSettings", false>;
}

declare class CardMediaSizePipe implements PipeTransform {
    transform(cardMediaSize: CardMediaSize | undefined, defaultValue: number): [number, number];
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CardMediaSizePipe, "cardMediaSize", false>;
}

declare class LabelStarTrimPipe implements PipeTransform {
    transform(key: string | null): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelStarTrimPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LabelStarTrimPipe, "lableStartTrim", false>;
}

declare class SplitPipe implements PipeTransform {
    transform(value: string, delimiter?: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SplitPipe, "split", false>;
}

declare class DynamicDarkColorPipe implements PipeTransform {
    transform(styleStr: string): string;
    private toDarkModeHSL;
    private rgbToHex;
    private parseColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicDarkColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicDarkColorPipe, "dynamicDarkColor", false>;
}

declare class ChunkArrayPipe implements PipeTransform {
    transform<T>(arr: T[] | null | undefined, size?: number): T[][];
    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkArrayPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ChunkArrayPipe, "chunkArray", false>;
}

declare class MapToChatMessagePipe implements PipeTransform {
    transform(message: Message, index: number, messages: Message[]): any;
    matchFilter(value: any, fitlerArgs: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapToChatMessagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MapToChatMessagePipe, "mapToChatMessage", false>;
}
type Message = {
    id: string;
    owner: User;
    createdAt: Date;
    deliveredAt: Date;
    readAt: Date;
};
type User = {
    id: string;
    avatar: string;
    name: string;
};

declare class ApiService {
    portalLoginUrl: string;
    executeUrl: string;
    private httpClient;
    loginPortal(): Observable<LoginResult>;
    GetCartableTemplate(keyOfCartableTemplates: CartableTemplateKey[]): Observable<{
        [key: string]: string;
    }>;
    loadPortalPageData(pageId: any, typeDefId: any): Observable<any>;
    loadPortal(portalId: any, typeDefId: any): Observable<PortalDataModel>;
    loadPortalSync(portalId: any, typeDefId: any): PortalDataModel;
    private getServerDataSync;
    private loadFormAjax;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
}

declare class PortalService {
    offsetTop: number;
    loginLoading: BehaviorSubject<boolean>;
    imageUrl: string;
    backgroundColor: string;
    loaded: boolean;
    formPanels: any;
    cachedImages: any;
    dateText$: Observable<string>;
    defaultRoute: string;
    cachedPageData: {
        [key: string]: Observable<PageDataModel>;
    };
    pages: PageDataModel[];
    rtlSource: BehaviorSubject<boolean>;
    userLoggedIn$: Observable<boolean>;
    dictionary: {
        [key: string]: BehaviorSubject<any>;
    };
    portalDataSource: BehaviorSubject<PortalDataModel | null>;
    portalSettings$: Observable<MetaobjectDataModel>;
    portalData$: Observable<PortalDataModel | null>;
    deviceSize$: Observable<AbbrevationDeviceSize>;
    rtl$: Observable<boolean>;
    dirValue$: Observable<'rtl' | 'ltr'>;
    routeInitialized$: Observable<boolean>;
    openForm$: Subject<void>;
    _isAnonumousSource: BehaviorSubject<boolean>;
    _pushAction$: BehaviorSubject<{
        notificationTag: string;
        action: string;
        moid: string;
        tpid: string;
    } | null>;
    DefaultPage: PageDataModel | null | undefined;
    private dcm;
    private apiService;
    private _log;
    private dialogService;
    private compiler;
    private _router;
    private _location;
    private _localStorage;
    private _document;
    private _applicationCtrlrService;
    private _deviceSizeSource;
    private _loggedInSource;
    private routeInitializedSource;
    private dateTextSource;
    private _navigationStart$;
    private _navigationEnd$;
    private _userPortalSettings$;
    private _cssUrlSource;
    private _cssVariableUrlSource;
    private _cssCustomUrlSource;
    private _searchTerm$;
    private _windowResize$;
    private _deviceLandscape$;
    private _standalone$;
    private _documentVisibilitychange$;
    constructor();
    get isRtl(): boolean;
    get userLoggedIn(): boolean;
    get pushAction$(): Observable<{
        notificationTag: string;
        moid: string;
        tpid: string;
        action: string;
    } | null>;
    get documentVisibilitychange$(): Observable<boolean>;
    get isStandalone(): boolean;
    get standalone$(): Observable<boolean>;
    get landscape$(): Observable<boolean>;
    get windowResize$(): Observable<void>;
    get portalData(): PortalDataModel | null;
    get searchTerm$(): Observable<string>;
    get cssUrl$(): Observable<SafeResourceUrl | null>;
    get cssVariableUrl$(): Observable<SafeResourceUrl | null>;
    get cssCustomUrl$(): Observable<SafeResourceUrl | null>;
    get userPortalSettings(): Record<string, MetaobjectDataModel>;
    get userPortalSettings$(): Observable<Record<string, MetaobjectDataModel>>;
    get deviceSize(): AbbrevationDeviceSize;
    get isAnonymous$(): Observable<boolean>;
    get navigationEnd$(): Observable<NavigationEnd | null>;
    get navigationStart$(): Observable<NavigationStart | null>;
    loadMo(id: string, typedefId: string): Observable<any>;
    setSiteImageUrl(backgroundColor: string, imageUrl: string): void;
    pushActionNext(pushAction: {
        notificationTag: any;
        moid: any;
        tpid: any;
        action: any;
    }): void;
    setSearchTerm(term: string): void;
    windowResize(): void;
    naviationEnd(event: NavigationEnd): void;
    naviationStart(event: NavigationStart): void;
    setUserPortalSettings(userPortalSettings: MetaobjectDataModel): void;
    setCssUrlTheme(themeUrl: SafeResourceUrl, cssVariableUrl?: SafeResourceUrl): void;
    setData(key: any, data: any): void;
    getData(key: any, defaultValue?: any): Observable<any>;
    getDataSync<T>(key: any, defaultValue?: any): T | null;
    createForReport(navItem: any): Observable<any>;
    renderUlvMainUi(navItem: any, vcr: ViewContainerRef, injector: Injector, isReportPage?: boolean): Observable<any>;
    getUlvMainUiComponent(customUlvMainUi: any, injector: Injector, isReportPage: any): Observable<ComponentRef<any>>;
    initialize(): void;
    _setDeviceSize(): void;
    _initalizeDeviceSize(): AbbrevationDeviceSize;
    compileModule(dependency: LibraryDepenecy): Observable<NgModuleFactory<any>>;
    getModule(dependency: LibraryDepenecy): Observable<any>;
    setValueOnObject(path: any, index: any, modules: any, object: any): void;
    getComponentType(moduleName: string, componentName: string, selector: string): Type<any> | undefined;
    getComponent(moduleName: string, _modulePath: string, componentName: string, selector: string, parentInjector: Injector): Observable<ComponentRef<any>>;
    loadJs$(path: any): Observable<string>;
    ReportExecuteById(reportId: string): Observable<MoForReportModel>;
    ReportExecute(reportName: string): Observable<MoForReportModel>;
    ReportExecutePromise(reportName: string): Promise<MoForReportModel>;
    addFormPanelCtrlr(id: any, formpanelCtrlr: any): void;
    setUserLoginStatus(status: boolean): void;
    getListOfChildPage(model: PortalDataModel | PageDataModel | null): PageDataModel[];
    extractAllPages(portalData: PortalDataModel | null): void;
    extractAllPages_Old(portalData: PortalDataModel | null): void;
    ssoLogin(): void;
    ssoLogout(): void;
    addChildPages(pageData: PageDataModel): void;
    createRoute(pageData: any, path: any, hasAuthorized: any, moduleName: any, redirectTo: any, isDynamicRoute: any): Route;
    createRoute2(pageData: any, path: any, hasAuthorized: any, moduleName: any, redirectTo?: string | null, isDynamicRoute?: boolean): Route;
    routeInitialized(): void;
    loginByAnonymous(): Observable<boolean>;
    getPageData(url: string, isRoot: boolean): Observable<PageDataModel | null>;
    resolveData(routePageData: any): Observable<PageDataModel | null>;
    addChildRoute(pageMo: MetaobjectDataModel, ChildPageList: MoForReportModel): void;
    addChildRoute_Old(pageMo: MetaobjectDataModel, ChildPageList: MoForReportModel): void;
    loadPortalData_Old1(): Observable<PortalDataModel>;
    loadPortalDataSync_Old2(): void;
    private _getDefaultPage;
    private _addPage;
    loadPortalDataSync(): void;
    ShowForm(e: {
        mo: MetaobjectDataModel;
        nama: string;
        afterReady?: (e: any) => void;
    }): void;
    get loginRoute$(): Observable<string>;
    RunBlMethodAsync<T>(methodName: string, parameters: any[]): Promise<any>;
    ExecuteNotificationAction(id: string, actionTitle: string): void;
    loadUserPortalSetting(): void;
    loadServerStartupData(): Promise<Record<string, any>>;
    _loadServerStartupData(resolve: any, reject: any): void;
    ShowFormPanelControl(formpanelCtrlr: any, router: Router, activatedRoute: ActivatedRoute, dialogComponent: Type<any> | null, isPage: boolean, vcr: ViewContainerRef, isReload?: boolean): void;
    loadSystem(id?: number): Promise<PortalDataModel>;
    private _addToCachePageData;
    private _getUlvParamsBy;
    private _reportExecutePromise;
    private _removePushAction;
    private _checkLocalStoragePushAction;
    private _initAfterLoginFormData;
    private _setRtl;
    private _initVisibilityChange;
    private _initStandalone;
    private _initPushActions;
    private _initLandscape;
    private findPageByRoute;
    private getNgModuleFactory;
    private getRegisteredModules;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalService>;
}
interface LibraryDepenecy {
    name: string;
    kebabName: string;
    umd: string;
    exportAs: string[];
}
interface BreadCrumbInfo {
    label: string;
    url: string;
    route: ActivatedRoute;
}

declare class BreadcrumbService {
    readonly breadcrumbs$: Observable<BreadCrumbInfo[]>;
    private router;
    private readonly _breadcrumbs$;
    constructor();
    private addBreadcrumb;
    private getLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
}

declare class ContainerService implements OnDestroy {
    oldActiveSystem: any | null;
    detachParent: boolean;
    masterDetails: boolean;
    paramId$: Observable<ParamMap>;
    routeEvents$: Observable<Event>;
    isMobile: boolean;
    FormPanelCtrlr: any;
    protected readonly _activatedRoute: ActivatedRoute;
    protected readonly _router: Router;
    protected readonly _portalService: PortalService;
    protected readonly _onDestroy$: Subject<void>;
    private _parentService;
    private _viewContainerRef;
    private _viewRef;
    private _scrollTop;
    private _elDomScrollbar;
    private _el;
    constructor();
    /** Inserted by Angular inject() migration for backwards compatibility */
    ngOnDestroy(): void;
    setViewContainerRef(viewContainerRef: ViewContainerRef): void;
    hideFormPage(): void;
    showFormPage(): void;
    navigate(navigation: any[], isRelative: any, queryParams: any, state: any): void;
    navigateMasterDetails(navigation: any[], isRelative: any, queryParams: any, data: any): void;
    private detach;
    private _setScrollPosition;
    private _restoreScrollPostion;
    private insert;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContainerService>;
}

declare abstract class ContainerComponent extends BaseComponent implements OnInit, AfterViewInit, OnDestroy {
    containerRef: ViewContainerRef;
    oldContainerContainer: ContainerComponent;
    oldNavigation: any;
    parentContainer: any;
    detachParent: any;
    deviceSize: AbbrevationDeviceSize;
    isMobile: boolean;
    id: string;
    protected _activatedRoute: ActivatedRoute;
    protected _portalService: PortalService;
    protected _vcr: ViewContainerRef;
    protected _barsaDialogService: BarsaDialogService;
    protected _injector: Injector;
    protected _router: Router;
    protected _cdr: ChangeDetectorRef;
    protected _renderer2: Renderer2;
    protected _dialogService: string | null;
    protected _containerService: ContainerService | null;
    protected _formDialogComponent: Type<any> | null;
    private _viewRef;
    constructor();
    get injector(): Injector;
    get cdr(): ChangeDetectorRef;
    get vcr(): ViewContainerRef;
    ngOnInit(): void;
    ngOnDestroy(): void;
    detach(): void;
    reAttach(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContainerComponent, "bnrc-container", never, {}, {}, never, never, false, never>;
}

declare class CustomInjector implements Injector {
    private parentInjector;
    private additionalTokens;
    private activatedRoute?;
    constructor(parentInjector: Injector, additionalTokens: WeakMap<any, any>, activatedRoute?: ActivatedRoute | undefined);
    get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
}
declare class DialogParams implements OnDestroy {
    context: any;
    afterClosed$: Observable<any>;
    private afterClosed;
    constructor();
    close(result?: any): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogParams, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogParams>;
}
declare class BarsaDialogService {
    containerComponent: ContainerComponent;
    protected injector: Injector;
    showForm(component: Type<any>, context: any, container: ViewContainerRef): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BarsaDialogService>;
}

declare class DynamicComponentService {
    requires: Record<string, any>;
    private cfr;
    private _injector;
    private _dynamicModuleWithComponents;
    private _compiler;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    addDynamicModuleResolver(modules: {
        [key: string]: () => Promise<any>;
    }): Promise<Record<string, any>>;
    addModuleWithComponents(moduleName: string, ngModuleRef: any): void;
    getComponentType(componentSelector: string, componentName: string, moduleName: string): Type<any> | undefined;
    getComponentBySelector(selector: string, componentName: string, moduleName: string, injector: Injector): Observable<ComponentRef<unknown>>;
    getComponentByName(componentName: string, moduleName: string, injector: Injector): Observable<ComponentRef<unknown>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentService>;
}

declare class FormPanelService extends BaseComponent {
    context$: Observable<any>;
    searchPanelIsObject$: Observable<boolean>;
    isSearchPanel$: Observable<boolean>;
    isSearcPanelInSideContent$: Observable<boolean>;
    workflowPanelUi$: Observable<any>;
    mo$: Observable<MetaobjectDataModel>;
    view$: Observable<any>;
    toolbarItems$: Observable<any[]>;
    workflowButtons$: Observable<any[]>;
    maxContentWidth$: Observable<string>;
    wizardNextStep$: Observable<void>;
    wizardPreviousStep$: Observable<void>;
    layout$: Observable<any>;
    forceClose$: Observable<void>;
    groupLayout$: Observable<LayoutSetting>;
    isSimpleForm$: Observable<boolean>;
    formWidth$: Observable<string>;
    toolbarVisible$: Observable<boolean>;
    headerLayout$: Observable<IHeaderLayout>;
    _hideClose$: BehaviorSubject<boolean>;
    _hideTitle$: BehaviorSubject<boolean>;
    _hidePin$: BehaviorSubject<boolean>;
    title$: Observable<string>;
    headerDescription$: Observable<string>;
    headerRemoveContentPadding$: Observable<boolean>;
    headerSubtitle$: Observable<string>;
    avatar$: Observable<any>;
    circleAvatar$: Observable<boolean>;
    mask$: Observable<boolean>;
    formHeight$: Observable<number>;
    fieldDict$: Observable<{
        [key: string]: string;
    } | undefined>;
    formContainerDom: HTMLElement;
    ColonInLabel: boolean;
    private _context;
    private _contextSource;
    private _formHeightSource;
    private _searchPanelIsObjectSource;
    private _isSearchPanelSource;
    private _isSearcPanelInSideContent;
    private _workflowPanelUiSource;
    private _infobars$;
    private _moSource;
    private _viewSource;
    private _sidebarState$;
    private _toolbarItemsSource;
    private _titleSource;
    private _maxContentWidthSource;
    private _wizardNextStepSource;
    private _wizardPreviousStepSource;
    private _layoutSource;
    private _forceCloseSource;
    private _groupBRuleSource;
    private _isSimpleFormSource;
    private _formWidthSource;
    private _toolbarVisibleSource;
    private _headerLayoutSource;
    private _headerTitleSource;
    private _maskSource;
    private _headerRemoveContentPaddingSource;
    private _hideBreadCrumbSource;
    private _headerDescriptionSource;
    private _hideFooter$;
    private _canSend$;
    constructor();
    get infobars$(): Observable<Array<InfoBarType>>;
    get hideFooter$(): Observable<boolean>;
    get sidebarState$(): Observable<'open' | 'close'>;
    get hideBreadCrumb$(): Observable<boolean>;
    get hidePin$(): Observable<boolean>;
    get hideClose$(): Observable<boolean>;
    get hideTitle$(): Observable<boolean>;
    get canSend$(): Observable<boolean>;
    get mo(): MetaobjectDataModel;
    set context(val: any);
    hideFooter(hideFooter: boolean): void;
    setFormHeight(val: number): void;
    destroy(): void;
    toolbarClick(btn: any): void;
    wfChoice(btn: any): void;
    changeSidebarState(state: 'open' | 'close'): void;
    hideInfoBar(id: any): void;
    protected _initialize(context: any): void;
    protected _prepareView(view: any): void;
    protected _filterToolbarItems(items: Array<any>): Array<any>;
    protected _getHeaderLayout(view: any): IHeaderLayout;
    protected _prepareLayoutComponent(view: FormViewSetting): void;
    protected _getIsSimpleForm(view: FormViewSetting): boolean;
    protected _getToolbarVisibility(context: any): boolean;
    protected _getMaxContentWidth(view: any): string;
    protected _addListener(context: any): void;
    protected _showInfobar(id: any, text: any, type: any, buttons: any, handler: any, icon: any): void;
    protected _refresh(): void;
    protected _forceClose(): void;
    protected _maskChanged(mask: any): void;
    protected _toolbarItemsChanged(items: any): void;
    protected _titleChanged(title: any): void;
    protected _wizardNextStep(): void;
    protected _wizardPreviousStep(): void;
    protected _doLayout(context: any): void;
    protected _closeSideNavigator(): void;
    protected _groupBRuleChanged(groupItem: LayoutSetting): void;
    protected _prepareContext(context: any): void;
}

declare class FormService {
    formList$: Observable<string[]>;
    private fromListSubject;
    constructor();
    openCompose(formComposeId: string): void;
    closeCompose(formComposeId: string): void;
}

declare class HorizontalLayoutService {
    displayTextFlexColumn$: Observable<boolean>;
    private controlFlexColumnSource;
    constructor();
    setFlexColumn(id: any, val: boolean): void;
}

declare class LayoutService {
    rootRendered$: Observable<boolean>;
    maxWidth$: Observable<number>;
    refreshLayout$: Observable<void>;
    horizontal$: Observable<any[]>;
    id: string;
    isTab: boolean;
    private rendered;
    private maxWidth;
    private refreshLayoutSource;
    private horizontalSource;
    private _listOfHorizontal;
    constructor();
    setRendered(val: boolean): void;
    setMaxWidth(val: any): void;
    refreshLayout(): void;
    addHorizontal(id: any): void;
    removeHorizontal(id: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
}

declare class UiService {
    tabSelected: Subject<any>;
    tabSelected$: Observable<any>;
    id: string;
    menuToggle$: Observable<boolean>;
    private menuToggleSubject;
    constructor();
    toggleMenu(toggle: boolean): void;
    setTabSelected(val: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UiService>;
}

declare class UlvMainService {
    moDataListSource: BehaviorSubject<MetaobjectDataModel[]>;
    context$: Subscription;
    viewer$: Observable<any>;
    conditionalFormats$: Observable<any>;
    hideToolbar$: Observable<boolean>;
    mask$: Observable<boolean>;
    viwerMask$: Observable<boolean>;
    visible$: Observable<boolean>;
    enable$: Observable<boolean>;
    readonly$: Observable<boolean>;
    menuItems$: Observable<MenuItem[]>;
    title$: Observable<{
        text: string;
        image: string;
    }>;
    searchPanelUi$: Observable<any>;
    pagingSetting$: Observable<PagingSetting | null>;
    toolbarButtons$: Observable<any[]>;
    destroy$: Observable<void>;
    moDataList$: Observable<MetaobjectDataModel[]>;
    reportId$: Observable<string>;
    allowInlineEdit$: Observable<boolean>;
    inlineEditMode$: Observable<boolean>;
    onlyInlineEdit$: Observable<boolean>;
    context: any;
    openSearchPanelHiddenSettings$: Observable<void>;
    openSearchFilesManage$: Observable<void>;
    searchPanelMoChanged$: Observable<boolean>;
    allSearchPanelSettings$: Observable<SearchPanelSettings[]>;
    layoutInfo$: Observable<any>;
    selectedSearchPanelSettingsId$: Observable<string>;
    selectedSearchPanelSettings$: Observable<SearchPanelSettings | undefined>;
    newInlineEditMo$: Observable<MetaobjectDataModel | null>;
    _cartableTemplates$: BehaviorSubject<{
        [key: string]: FormSetting;
    }>;
    _cartableChildsMo$: BehaviorSubject<{
        [key: string]: MetaobjectDataModel;
    } | null>;
    selectedCount$: Observable<number>;
    hideUlvPageTitle$: Observable<boolean>;
    uiViewerSelector$: Observable<string>;
    private _bbbPipe;
    private _apiService;
    private _setUiViewerSelector$;
    private _gridFreeColumnSizing$;
    private _layoutInfoSource;
    private _contextSource;
    private _canSaveGridSetting$;
    private _inDialog$;
    private _isMultiSelect$;
    private _fullscreen$;
    private _conditionalFormatsSource;
    private _reportSource;
    private _viewerControlSource;
    private _hideToolbarSource;
    private _onDestroy$;
    private _maskSource;
    private _showContextMenuSource;
    private _viewerMaskSource;
    private _visibleSource;
    private _enableSource;
    private _readonlySource;
    private _menuItemsSource;
    private _onlyInlineEditSource;
    private _inlineEditModeSource;
    private _allowInlineEditSource;
    private _cartableKeySeperator;
    private _titleSource;
    private _hideUlvPageTitle$;
    private _searchPanelUiSource;
    private _pagingSettingSource;
    private _toolbarButtonsSource;
    private _toolbarButtonsWorkflowButtons;
    private _destroySource;
    private _firstApplyAutomatically;
    private _controlInfosMetaobject;
    private _selectedSearchPanelSettingsIdSource;
    private _defaultSearchPanelSettingsSource;
    private _allSearchPanelSettingsSource;
    private _cssBackgroundSource;
    private _shortCutsSource;
    private _hidePagingSource;
    private _openSearchPanelHiddenSettingsSource;
    private _openSearchFilesManageSource;
    private _searchPanelMoChangedSource;
    private _newInlineEditMoSource;
    private _hideSearchapanelSource;
    private _workflowShareButtons;
    private _prepareMoForNewForm$;
    private _hideViewerLoadingSource;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    get hideViewerLoading$(): Observable<boolean>;
    get hidePaging$(): Observable<boolean>;
    get prepareMoForNewForm$(): Observable<MetaobjectDataModel>;
    get showContextMenu$(): Observable<void>;
    get gridFreeColumnSizing$(): Observable<boolean>;
    get canSaveGridSetting$(): Observable<boolean>;
    get inDialog$(): Observable<boolean>;
    get isMultiSelect$(): Observable<boolean>;
    get fullscreen$(): Observable<boolean>;
    get cartableChildsMo$(): Observable<{
        [key: string]: MetaobjectDataModel;
    } | null>;
    get cartableTemplates$(): Observable<{
        [key: string]: FormSetting;
    } | null>;
    get searchPanelUi(): any;
    get reportId(): string | undefined;
    get allSearchPanelSettings(): SearchPanelSettings[];
    get hideSearchpanel$(): Observable<boolean>;
    get hideSearchpanel(): boolean;
    get cssBackground$(): Observable<CssBackground | null>;
    get shortCuts$(): Observable<ShortCuts>;
    prepareMoForNewForm(mo: MetaobjectDataModel): void;
    setShortCuts(shortCuts: ShortCuts): void;
    setBackground(cssBackground: CssBackground): void;
    hidePaging(hide: boolean): void;
    setUiViewerClass(selector: string): void;
    hideUlvTitlePage(): void;
    setCanSaveGridSettings(val: boolean): void;
    executeToolbarButton(itemId: string, options?: any): void;
    addWorkflowButtonsInToolbar(e: ShareButtonsChoiceDef): void;
    _excludeWrapperFromMo(mo: MetaobjectDataModel): MetaobjectDataModel;
    onWorkflowButtonInToolbarClick(shareButton: {
        text: string;
    }): void;
    setTitle(title: string): void;
    ulvSetHideViewerLoading(hideViewerLoading: boolean): void;
    toggleHideSearchpanel(val?: boolean): void;
    setContext(context: any): void;
    setInDialog(val: boolean): void;
    setIsMultiSelect(val: boolean): void;
    setFullscreen(val: boolean): void;
    createNewInlineMo(isChecked: boolean): MetaobjectDataModel;
    setLayoutInfo(layoutInfo: any): void;
    destroy(): void;
    pageSizeChanged(pageIndex: any): void;
    pageChanged(pageIndex: any): void;
    reSetMoDataList(moDataList?: MetaobjectDataModel[]): void;
    clearSearch(): void;
    search(): void;
    getValueInlineEdit(): boolean;
    getAllowInlineEdit(): boolean;
    setInlineEdit(value: boolean): void;
    openSearchFieldsHiddenSettings(): void;
    openSearchFilesManage(): void;
    searchPanelMoChanged(change: boolean): void;
    loadSearchPanelSettings(): void;
    addSearchPanelSettings(searchPanelSettings: SearchPanelSettings): void;
    saveSearchPanelSetting(selectedSearchPanelSettings: SearchPanelSettings): void;
    applySearchPanelSettings(searchPanelSettings: SearchPanelSettings | undefined): void;
    getSearchPanelMo(): MetaobjectDataModel;
    getSearchPanelFieldsSetting(): Array<Partial<GeneralControlInfoModel>>;
    setAndApplySearchPanelSettingFieldsSetting(fieldsSetting: ColumnInfoType[]): void;
    updateSearchPanelSettings(allSearchPanelSettings: SearchPanelSettings[]): void;
    removeSearchPanelSettings(searchPanelSettingsId: string): void;
    changeSelectedSearchPanel(selectedSearchPanelSettingsId: string): void;
    loadMetaConditionsControlInfos(typeDefId: string, fieldDbNames: string[]): Observable<GeneralControlInfoModel[]>;
    protected _createWorkflowShareButtons(e: ShareButtonsChoiceDef): string[];
    protected _initCreateNewInlineMo(context: any): void;
    protected _isComposite(context: any): boolean;
    protected _addEventListener(context: any): void;
    protected _initialize(context: any): void;
    protected _initGridFreeColumnSizing(context: any): void;
    protected _initCartablesFormTemplate(context: any): void;
    protected _initSearchpanel(context: any): void;
    protected _initConditionalFormats(context: any): void;
    protected _initMenuItems(context: any): void;
    protected _initReport(context: any): void;
    protected _initMoDataList(context: any): void;
    protected _cartableChildsMo(context: any): void;
    protected _initPagingSetting(context: any): void;
    protected _initTitle(context: any): void;
    protected _initReadonly(context: any): void;
    protected _initEnable(context: any): void;
    protected _initVisible(context: any): void;
    protected _initToolbarButtons(context: any): void;
    protected _initInlineEditMode(context: any): void;
    protected _initAllowInlineEdit(context: any): void;
    protected _initOnlyInlineEdit(context: any): void;
    protected _initViewerControl(context: any): void;
    protected _initHideToolbar(context: any): void;
    protected _unscubscribeContext(): void;
    protected _conditionalFormatsChanged(conditionalFormats: any): void;
    protected _moDataListChanged(moDataList: any): void;
    protected _checkCartableWorkflowShareButtons(moDataList: MetaobjectDataModel[]): void;
    protected _viewerControlChanged(viewerControl: any): void;
    protected _maskChanged(mask: boolean): void;
    protected _showContextMenu(xy: any): void;
    protected _viewerMaskChanged(viewerMask: boolean): void;
    protected _readonlyChanged(readonly: boolean): void;
    protected _visibleChanged(viewerMask: boolean): void;
    protected _removeExtraMenuItems(menuItems: MenuItem[]): MenuItem[];
    protected _menuItemsChanged(menuItems: any[]): void;
    protected _titleChanged(titleObj: {
        text: string;
        image: string;
    }): void;
    protected _searchPanelChanged(searchPanel: any): void;
    protected _pagingSettingChanged(pageingSetting: any): void;
    protected _toolbarButtonsChanged(buttons: any[]): void;
    protected _enableChanged(enable: boolean): void;
    protected _destroyChanged(): void;
    protected _existInlineEdit(): void;
    protected _addDefaultSearchPanelSettings(searchPanel: any): void;
    protected _loadSearchPanelSettings(reportId: any): void;
    protected resetSearchPanelSettings(searchPanelUi: any): void;
    protected _loadCartableTemplate(keyOfCartableTemplates: Set<string>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UlvMainService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UlvMainService>;
}

declare class UploadService {
    uploadingState$: Observable<IUploadingState>;
    cancelation$: Subject<void>;
    uploadURL: string;
    private httpClient;
    private _uploadingStateSource;
    constructor();
    upload(data: FormData, fdId: string, key?: string): Observable<IUploadingState>;
    compressFiles$(files: File[]): Observable<FormData>;
    private _setUploadingStatus;
    private compressFiles;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
}

declare class NetworkStatusService {
    get networkStatus$(): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkStatusService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkStatusService>;
}

interface RecordedAudioOutput {
    blob: Blob;
    title: string;
}
declare class AudioRecordingService {
    private stream;
    private recorder;
    private interval;
    private startTime;
    private _recorded;
    private _recordingTime;
    private _recordingFailed;
    getRecordedBlob(): Observable<RecordedAudioOutput>;
    getRecordedTime(): Observable<string>;
    recordingFailed(): Observable<string>;
    startRecording(): void;
    abortRecording(): void;
    stopRecording(): void;
    private record;
    private toString;
    private stopMedia;
    static ɵfac: i0.ɵɵFactoryDeclaration<AudioRecordingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AudioRecordingService>;
}

interface RecordedVideoOutput {
    blob: Blob;
    url: string;
    title: string;
}
declare class VideoRecordingService {
    private stream;
    private recorder;
    private interval;
    private startTime;
    private _stream;
    private _recorded;
    private _recordedUrl;
    private _recordingTime;
    private _recordingFailed;
    getRecordedUrl(): Observable<string>;
    getRecordedBlob(): Observable<RecordedVideoOutput>;
    getRecordedTime(): Observable<string>;
    recordingFailed(): Observable<string>;
    getStream(): Observable<MediaStream>;
    startRecording(conf: any): Promise<any>;
    abortRecording(): void;
    stopRecording(): void;
    private record;
    private toString;
    private processVideo;
    private stopMedia;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoRecordingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VideoRecordingService>;
}

declare class LocalStorageService {
    localstorage: boolean;
    constructor();
    setItem(key: string, value: string): void;
    getItem(key: string): string | null;
    remove(key: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
}

declare class IndexedDbService {
    _db: IDBDatabase | null;
    constructor();
    open(dbName: string, version: number): void;
    delete(dbName: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDbService>;
}

declare class BarsaStorageService {
    STARTUP_DATA_KEY: string;
    DBNAME_KEY: string;
    DBNAME_VERSION_KEY: string;
    BAZAVARI_VERSION_KEY: string;
    private _logService;
    private _localStorageService;
    private _indexedDbService;
    protected get currentBazavariVersion(): string;
    interceptXhr(): void;
    init(): void;
    deleteDatabase(): void;
    openDatabase(version: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BarsaStorageService>;
}

declare class PromptUpdateService {
    private _logService;
    private swUpdate;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    checkForUpdate(): void;
    promptUser(callback: any): void;
    showError(callback: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PromptUpdateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PromptUpdateService>;
}

interface NotificationPopupService {
    popupNotify(msg: any, title: any, type: any, image: any, mo: any, uiOptions: any, otherOptions: any): any;
}

declare class NotificationService {
    pageCount: number;
    pageIndex: number;
    userNotificationSettings: UserNotificationSetting;
    protected _popupService: NotificationPopupService;
    private _logService;
    private _bbbTranslate;
    private _domSanitizer;
    private _serviceWorkerNotification;
    private _portalService;
    private _ngZone;
    private _notifications$;
    private _notificationUnreadCount$;
    private _notificationLoading$;
    private _notifiationCountLoaded$;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    get notificationCountLoaded$(): Observable<boolean>;
    get notificationUnreadCount$(): Observable<number>;
    get notifications$(): Observable<MetaobjectDataModel[]>;
    get notificationLoading$(): Observable<boolean>;
    ShowNotificationRelatedMo(e: {
        tag: string;
        mo: MetaobjectDataModel;
        nama: string;
    }): void;
    handleTopic(eventTopic: any, _content: any, _ownerKey: any): void;
    addNotification(msg: string, title: string, _type: string, image: string, mo: any, uiOptions: NotifyOptions, otherOptions: Record<string, any>): void;
    LoadUnreadNotificationCount(): void;
    get SupportNotifications(): boolean;
    showNotification(notificationItem: NotificationItem, mo: MetaobjectDataModel | null, uiOptions: NotifyOptions, otherOptions: Record<string, any>): void;
    private notificationLoading;
    private _setNotificationLoading;
    private _popupNotify;
    private _prepareProperties;
    private _inAppNotify;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}
interface UserNotificationSetting extends MetaobjectDataModel {
    DisableCartableGroups: MoForReportModel;
    Enable: boolean;
}

declare class ServiceWorkerNotificationService {
    hasRegistration: boolean;
    private _logService;
    private _swPush;
    private _portalService;
    private _notificationPermissionAllowed;
    constructor();
    get isEnabled(): boolean;
    closeNotifications(tags: string[]): Promise<void>;
    showNotification(payload: ExNotificationPayload): Promise<void>;
    private handlePermission;
    private permissionQuery;
    private permissionError;
    private getSw;
    private _isSupported;
    private _isActionsSupported;
    private _isIconSupported;
    private isBadgeSupported;
    private _isDirSupported;
    private isImageSupported;
    private isTitleBodySupported;
    private isVibrateSupported;
    private isTimestampSupported;
    private isTagSupported;
    private isSoundSupported;
    private isSilentSupported;
    private isReqInterSupported;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceWorkerNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceWorkerNotificationService>;
}

declare class ColumnService {
    private _uiControlRendered;
    get uiControlRendered(): Observable<void>;
    constructor();
    controlRendered(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnService>;
}

declare class ServiceWorkerCommuncationService {
    _serviceWorker: ServiceWorker;
    _hidden: boolean;
    operationName: string;
    private _localStorage;
    private _logService;
    private _portalService;
    private _swPush;
    private _httpClient;
    private _subscription;
    get token2(): string;
    get httpOptions(): any;
    init(): void;
    protected _handlePushSubscirption(): void;
    protected _subscribe(): void;
    protected _setDefaultOptions(): void;
    protected _isLoggedIn(isLoggedIn: boolean): void;
    protected _visibilitychange(documentIsHidden: boolean): void;
    protected _postServiceWorker(message: any): void;
    private _testSend;
    private _initPushSubscription;
    private _handlePushUnSubscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceWorkerCommuncationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceWorkerCommuncationService>;
}

declare class SaveScrollPositionService {
    private _scrollPositionSource;
    get scrollPosition$(): Observable<{
        key: string;
        scrollTop: number;
    }>;
    getScrollPosition(key: string): number;
    setScrollPosition(key: string, scrollTop: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SaveScrollPositionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SaveScrollPositionService>;
}

declare class RoutingService implements OnDestroy {
    oldActiveSystem: any | null;
    _activatedRoute: ActivatedRoute;
    router: Router;
    isSidebar: boolean;
    handleReport: (repId: string, navId: string) => boolean;
    _Object: {
        ShowSystemContainerPage: (navItem: any) => void;
    };
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RoutingService>;
}

declare class GroupByService {
    groupBy$: Observable<SortSetting[]>;
    private _groupBy;
    constructor();
    setGroupBy(groupBy: SortSetting[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GroupByService>;
}

declare class LayoutMainContentService {
    mainContentHeight$: Observable<number>;
    id: string;
    private mainContentHeightSource;
    constructor();
    setMainContentHeight(height: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutMainContentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutMainContentService>;
}

declare class TabpageService {
    itemCount: number;
    setItemCount(itemCount: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabpageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabpageService>;
}

declare class InMemoryStorageService {
    private _dictionary;
    setItem(key: string, value: any): void;
    getItem(key: string): any;
    remove(key: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryStorageService>;
}

declare class ShellbarHeightService {
    shellbarHeight$: Observable<string>;
    private _dict;
    constructor();
    add(variableValue: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarHeightService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ShellbarHeightService>;
}

declare class ApplicationCtrlrService {
    deviceSize: AbbrevationDeviceSize;
    private _selectedNavGroupItemId$;
    private _selectedReportId$;
    private _selectedNavGroupId$;
    private _sidebarToggle$;
    private _selectedAppTileGroup$;
    private _appMenuItems$;
    private _systemsUi$;
    private _selectedSystemId$;
    private _selectedSystemNavUi$;
    private _selectedCommandId$;
    private _isCommandGroupsSelected$;
    private _customApplicationUi;
    private _customApplicationMenuBodyUi;
    private _isMobile;
    private _document;
    private _router;
    get appMenuItems$(): Observable<AppMenu[]>;
    get systemCommandGroups$(): Observable<Array<CommandGroup>>;
    get selectedCommand$(): Observable<string>;
    get systemWorkflowList$(): Observable<Array<WorkflowItem>>;
    get selectedSystemNavUi$(): Observable<CustomSystemNavUi | null>;
    get isCommandGroupsSelected$(): Observable<boolean>;
    get selectedSystemId$(): Observable<string>;
    get selectedAppTileGroup$(): Observable<string>;
    get sidebarToggle$(): Observable<boolean>;
    get sidebarToggle(): boolean;
    get selectedNavGroupId$(): Observable<string>;
    get selectedNavGroupItemId$(): Observable<string>;
    get selectedReportId$(): Observable<string>;
    get selectedSystemId(): string;
    getSelectedNavGroupItemId(systemId: string): string;
    getSelectedReportId(systemId: string): string;
    initialize(callback: any): void;
    systemChange(systemId: string): void;
    selectAppTileGroup(id: string): void;
    setCommandGroupsSelected(isSelected: boolean): void;
    selectedSystem(systemId: string): void;
    selectSystemCommand(command: Command): void;
    selectSystemCommandId(id: string): void;
    selectNavGroupItem(navGroupItemId: string): void;
    selectNavGroup(navGroupId: string, toggle?: boolean): void;
    sidebarToggled(value: boolean): void;
    selectedReportId(reportId: string): void;
    loadSystem(id: any, resolve: any, reject: any): void;
    protected flattenLeafCommands(commands: Command[]): Command[];
    protected _mergeToSystemGroup(commandGroups: CommandGroup[]): CommandGroup[];
    protected _handleEvents(): void;
    protected _appMenuBodyUi_itemsChanged(items: AppMenu[]): void;
    protected _addSystemUi(_systemUi: any): void;
    protected _addToMainTabPanel(_customSystemUi: any): void;
    protected _selectedSystemChanged(systemId: any, _forceRelayout?: boolean): void;
    protected _selectSystem(system: CustomSystemUi | undefined): void;
    protected _setStatusBarValues(_statusbarValues: any): void;
    protected _showReleaseNoteWindow(_releaseNoteData: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationCtrlrService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationCtrlrService>;
}

interface FieldSetting {
    [key: string]: any;
    ControlFieldCaption: string;
    ControlFieldCaptionTranslated: string;
    ControlFieldDefId: string;
    ControlName: string;
    RelatedFieldList: [];
    Hide: boolean;
    DontShowRecalculateButton?: boolean;
    xtype: string;
    LabelPosition: string;
    IsMandatory: boolean;
    IsVisible: boolean;
    ShowLabel: boolean;
    IsReadOnly: boolean;
    IsEnabled: boolean;
    IsBold: boolean;
    IsAutomatic: boolean;
    JsonExtraProp: any | null;
    FieldIcon: string;
    IsLtr: boolean;
}
declare abstract class FieldBaseComponent extends BaseComponent implements OnInit, OnDestroy, AfterViewInit {
    context: any;
    focusControl: boolean;
    layoutInfo: any;
    value: any;
    width: number;
    height: number;
    formHeight: number;
    inlineEdit: boolean;
    cellEdit: boolean;
    formContainer: HTMLElement;
    id: string;
    parametes: MetaobjectDataModel;
    valueChange: EventEmitter<any>;
    formmatedValue: EventEmitter<any>;
    isMobile: boolean;
    isTablet: boolean;
    JsonExtraProp: any;
    parameters: any;
    Setting: GeneralControlInfoModel;
    refresh$: Observable<any>;
    value$: Observable<any>;
    disable$: Observable<boolean>;
    readonly$: Observable<boolean>;
    disableOrReadonly$: Observable<boolean>;
    deviceSize$: Observable<AbbrevationDeviceSize>;
    mobileConfig: any;
    get customFieldInfo(): MetaobjectDataModel;
    protected _portalService: PortalService;
    protected _bbbPipe: BbbTranslatePipe;
    protected _picFieldSrc: PictureFieldSourcePipe;
    protected _numeralPipe: NumeralPipe;
    protected _cdr: ChangeDetectorRef;
    protected _renderer2: Renderer2;
    protected _activatedRoute: ActivatedRoute;
    protected _domSanitizer: DomSanitizer;
    protected _dialogService: any;
    protected _uploadService: UploadService | null;
    protected _dateService: DateService | null;
    protected _audioRecorder: AudioRecordingService | null;
    protected _videoRecoder: VideoRecordingService | null;
    protected _columnService: ColumnService | null;
    private _refreshSource;
    private _valueChangedSource;
    private _disableChangedSource;
    private _readonlyChangedSource;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    fireContextEvent(event: string, value: any, value1?: any, value2?: any): void;
    protected _focusToFirstFocusableElement(): void;
    protected _setMobileConfig(): void;
    protected _addListener(): void;
    protected _removeListener(): void;
    protected _configChaned(_: any): void;
    protected _setValue(value: any): void;
    protected _setRefresh(value: any): void;
    protected _setDisable(value: any, changeDetect?: boolean): void;
    protected _setReadonly(value: any, changeDetect?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldBaseComponent, "bnrc-field-base", never, { "context": { "alias": "context"; "required": false; }; "focusControl": { "alias": "focusControl"; "required": false; }; "layoutInfo": { "alias": "layoutInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "formHeight": { "alias": "formHeight"; "required": false; }; "inlineEdit": { "alias": "inlineEdit"; "required": false; }; "cellEdit": { "alias": "cellEdit"; "required": false; }; "formContainer": { "alias": "formContainer"; "required": false; }; "id": { "alias": "id"; "required": false; }; "parametes": { "alias": "parametes"; "required": false; }; }, { "valueChange": "valueChange"; "formmatedValue": "formmatedValue"; }, never, never, false, never>;
}

declare class FormBaseComponent extends BaseComponent implements OnInit, OnDestroy {
    id: string;
    fullscreen: boolean;
    _typeDefName: string;
    _viewName: string;
    context: {
        [key: string]: any;
        config: any;
        Setting: FormSetting;
    };
    formClose: EventEmitter<any>;
    listFieldUi: any;
    isWizard: boolean;
    parameters: MetaobjectDataModel;
    isMobile: boolean;
    deviceSize$: Observable<'s' | 'm' | 'l' | 'xl'>;
    dirValue$: Observable<'rtl' | 'ltr'>;
    rtl$: Observable<boolean>;
    toolbarVisible$: Observable<boolean>;
    hideClose$: Observable<boolean>;
    hideTitle$: Observable<boolean>;
    hidePin$: Observable<boolean>;
    title$: Observable<string>;
    toolbarItems$: Observable<any[]>;
    workflowButtons$: Observable<any[]>;
    infobars$: Observable<InfoBarType[]>;
    headerLayout$: Observable<IHeaderLayout | null>;
    layout94$: Observable<any>;
    layout94: any;
    maxContentWidth$: Observable<string>;
    formWidth$: Observable<string>;
    headerDescription$: Observable<string>;
    headerRemoveContentPadding$: Observable<boolean>;
    headerSubtitle$: Observable<string>;
    avatar$: Observable<any>;
    circleAvatar$: Observable<boolean>;
    extendToolbarItems$: Observable<any[]>;
    workflowPanelUi$: Observable<any>;
    view$: Observable<FormViewSetting>;
    mo$: Observable<MetaobjectDataModel | null>;
    isSimple$: Observable<boolean>;
    fieldDict$: Observable<{
        [key: string]: string;
    } | undefined>;
    mask$: Observable<boolean>;
    isSearchPanel: boolean;
    isModal: boolean;
    isSubForm: boolean;
    modernTabs$: Observable<LayoutSetting[]>;
    modernTabContainerComponent: EjrayOlgo;
    isFormReport: boolean;
    landscape$: Observable<boolean>;
    standalone$: Observable<boolean>;
    hideBreadCrumb$: Observable<boolean>;
    breadCrumbs$: Observable<BreadCrumbInfo[]>;
    canSend$: Observable<boolean>;
    formVisibilityStatus: FormVisibilityStatus;
    protected _breadcrumbService: BreadcrumbService;
    protected _portalService: PortalService;
    protected _router: Router;
    protected _el: ElementRef<any>;
    protected _controlUiPipe: ControlUiPipe;
    protected _formPanelService: FormPanelService;
    protected _activatedRoute: ActivatedRoute;
    protected _cdr: ChangeDetectorRef;
    protected _style: HTMLStyleElement;
    protected _standalone: boolean;
    private _formIntersection;
    constructor();
    get forceClose$(): Observable<void>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onDismissInfobar(id: string): void;
    onClose(): void;
    onFullscreen(): void;
    onToolbarClick(btn: any): void;
    onWorkflowChoiceClick(wfChoice: any): void;
    fieldChange(fieldName: any, value: any): void;
    searchClick(): void;
    protected _onInView(e: any): void;
    protected obtainHeight(): void;
    private _setParamters;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormBaseComponent, "bnrc-form-base", never, { "context": { "alias": "context"; "required": false; }; }, { "formClose": "formClose"; }, never, never, false, never>;
}

declare class FormToolbarBaseComponent extends BaseComponent implements OnInit {
    buttons: any[];
    visible: boolean;
    size: any;
    device: any;
    deviceSize: any;
    rtl: boolean;
    landscape: boolean;
    standalone: boolean;
    shouldOverflow: boolean;
    toolbarVisible: boolean;
    isFirefox: boolean;
    dirValue: 'auto' | Direction;
    width: string | null;
    toolClick: EventEmitter<any>;
    _rtl: any;
    protected _cdr: ChangeDetectorRef;
    ngOnInit(): void;
    onToolClick(btn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormToolbarBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormToolbarBaseComponent, "bnrc-form-toolbar-base", never, { "buttons": { "alias": "buttons"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "size": { "alias": "size"; "required": false; }; "device": { "alias": "device"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "landscape": { "alias": "landscape"; "required": false; }; "standalone": { "alias": "standalone"; "required": false; }; "shouldOverflow": { "alias": "shouldOverflow"; "required": false; }; "toolbarVisible": { "alias": "toolbarVisible"; "required": false; }; "isFirefox": { "alias": "isFirefox"; "required": false; }; "dirValue": { "alias": "dirValue"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "toolClick": "toolClick"; }, never, never, false, never>;
}

interface NavigatorItem {
    [key: string]: any;
    Caption: string;
    FolderId: string;
    IconUrl: string;
    Id: string;
    IsRoot: boolean;
    IsTab: boolean;
    Name: string;
    NotLoaded: boolean;
    ReportId: string;
    Parent?: NavigatorItem;
    Items: NavigatorItem[];
}
interface SystemSetting {
    Id: string;
    Name: string;
    Caption: string;
    IconName: string;
    RootFolderId: string;
    IsLoaded: boolean;
    IsUiCreated: boolean;
    IsActive: boolean;
    FormSetting: string;
    CustomCodeError: string;
    HasVerifyPassword: boolean;
    Navigator: {
        Root: NavigatorItem;
    };
    ExtraData: any;
}
declare class SystemBaseComponent extends BaseComponent {
    context: {
        [key: string]: any;
        SystemData: SystemSetting;
        SystemNavUi: any;
        SystemContainerUi: any;
    };
    constructor();
    showFormPanel: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SystemBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SystemBaseComponent, "bnrc-system-base", never, { "context": { "alias": "context"; "required": false; }; "showFormPanel": { "alias": "showFormPanel"; "required": false; }; }, {}, never, never, false, never>;
}

interface ReportSetting {
    [key: string]: any;
    Id: string;
    Extra: any;
}
declare class ReportBaseComponent extends BaseComponent implements OnInit, AfterViewInit, OnDestroy {
    context: {
        [key: string]: any;
        Setting: ReportSetting;
    };
    currentPage: number;
    pageChange: EventEmitter<number>;
    pageSizeChange: EventEmitter<number>;
    defaultGridSetting: {
        ColSettingList: never[];
        AutoSizeColumns: boolean;
        SortSettingList: never[];
        Hidden: boolean;
    };
    itemSelector: string;
    allColumns: ReportViewColumn[];
    id: string;
    sortSettings: {
        IsGrouped: boolean;
        Name: string;
        SortDirection: string;
    }[] | null;
    parameters: any;
    fields: any;
    cssBackground$: Observable<CssBackground | null>;
    visibleColumns$: Observable<ReportViewColumn[]>;
    searchTerm$: Observable<string>;
    moDataList$: Observable<MetaobjectDataModel[]>;
    gridSetting$: Observable<GridSetting>;
    groupby$: Observable<SortSetting[]>;
    allChecked$: Observable<boolean>;
    pagingSetting$: Observable<PagingSetting | null>;
    deviceSize$: Observable<AbbrevationDeviceSize>;
    mask$: Observable<boolean>;
    title$: Observable<string>;
    inDialog$: Observable<boolean>;
    isMultiSelect$: Observable<boolean>;
    fullscreen$: Observable<boolean>;
    menuItems$: Observable<MenuItem[]>;
    toolbarButtons$: Observable<any[]>;
    toolbarEnable$: Observable<boolean>;
    hideToolbar$: Observable<boolean>;
    hideSearchpanel$: Observable<boolean>;
    selectedMo$: Observable<MetaobjectDataModel | undefined>;
    conditionalFormats$: Observable<any[]>;
    newInlineEditMo$: Observable<MetaobjectDataModel | null>;
    cartableTemplates$: Observable<{
        [key: string]: FormSetting;
    } | null>;
    cartableChildsMo$: Observable<{
        [key: string]: MetaobjectDataModel;
    } | null>;
    selectedCount$: Observable<number>;
    gridFreeColumnSizing$: Observable<boolean>;
    protected _portalService: PortalService;
    protected _ulvMainService: UlvMainService;
    protected _visibleColumnsSource: BehaviorSubject<ReportViewColumn[]>;
    protected searchTermSource: BehaviorSubject<string>;
    protected gridSettingSource: BehaviorSubject<GridSetting>;
    protected groupbySource: BehaviorSubject<SortSetting[]>;
    private _allCheckedSource;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    get moDataList(): MetaobjectDataModel[];
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onResetGridSettings(): void;
    protected _columnSummary(e: ColumnSummaryType): void;
    protected _gridSettingChanged(setting: any): void;
    protected _prepareMoForNewForm(_context: any, mo: any): void;
    protected _moDataListChanged(moDataList: any): void;
    protected _setAllChecked(items: MetaobjectDataModel[]): void;
    protected _handleColumnsResized(e: columnsResizedEventArgs): void;
    protected _setVisibleColumns(): void;
    protected applyGroupby(): void;
    protected _raiseRowClick(index: any, mo: any): void;
    protected _deviceSizeChanged(_: string): void;
    protected _windowResized(): void;
    protected _openMo(mo: any, i: any): void;
    protected updateGridSetting(setting: any, isSort?: boolean, raiseEvent?: boolean): void;
    protected updateSortSettings(sortSettings: any, raiseEvent?: boolean): void;
    protected _raiseEventUserSettingChanged(gridSetting: GridSetting): void;
    protected _ulvCommandClicked(mo: any, index: any): void;
    protected _checkedAll(): void;
    protected _removeCheckedAll(): void;
    protected _deselctAll(): void;
    protected _deselect(mo: any, index: any): MetaobjectDataModel;
    protected _select(mo: any, index: any): MetaobjectDataModel;
    protected _doCheckedAll(checked: any): void;
    protected _getSelected(): MetaobjectDataModel | null;
    protected refreshContextMoDataList(moDataList: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportBaseComponent, "bnrc-report-base", never, { "context": { "alias": "context"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, false, never>;
}

interface FieldSettings extends MetaobjectDataModel {
    ComponentParameter: MetaobjectDataModel;
    RelatedField: string;
}
interface ReportItemSetting extends MetaobjectDataModel {
    FieldSettings: {
        MoDataList: Array<FieldSettings>;
    };
}
declare class ReportItemBaseComponent extends BaseComponent implements OnInit {
    itemClick: EventEmitter<any>;
    classNames2: string;
    classNames: string;
    context: {
        [key: string]: any;
        Setting: ReportSetting;
    } | null;
    mo: MetaobjectDataModel;
    allColumns: any[];
    index: number;
    fields: any;
    parameters: ReportItemSetting | null;
    constructor();
    onClick(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportItemBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportItemBaseComponent, "bnrc-report-item-base", never, { "classNames": { "alias": "classNames"; "required": false; }; "context": { "alias": "context"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, false, never>;
}

interface ApplicationSetting {
    [key: string]: any;
    ConnectionInfo: string;
    AllowManagementWindow: boolean;
    DefaultSystemId: string;
    EnableCompactArray: boolean;
    EnableNotification: boolean;
    EnableScanner: boolean;
    ForceFormHelpButton: boolean;
    HideDeleteInForms: boolean;
    HideThemeButton: boolean;
    IsAdmin: boolean;
    IsInitializing: boolean;
    IsOnActivityDirectory: boolean;
    IsUser: boolean;
    MaxExcelExportRows: number;
    NewDateFix: boolean;
    NoLogout: boolean;
    ScannerAgentValidVersion: string;
    SecurityType: string;
    ShowDebugToolbar: boolean;
    ShowNextPrivious: boolean;
    SystemDict: {
        [key: string]: SystemSetting;
    };
    Version: string;
    VersionSpl: string;
    User: {
        DispalyName: string;
        Id: string;
        Name: string;
    };
    WebConfig: {
        Workflow: {
            ShowInfoBar: true;
            ShowToolbar: true;
            ShowUserMsg: true;
        };
    };
}
declare class ApplicationBaseComponent extends BaseComponent {
    context: {
        [key: string]: any;
        Setting: ApplicationSetting;
    };
    selectedSystemId: string;
    systemList: any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationBaseComponent, "bnrc-application-base", never, { "context": { "alias": "context"; "required": false; }; "selectedSystemId": { "alias": "selectedSystemId"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LayoutItemBaseComponent extends BaseComponent {
    config: LayoutSetting;
    isPanel: boolean;
    maxLabelWidth: number;
    rtl: boolean;
    isSearchPanel: boolean;
    isSearcPanelInSideContent: boolean;
    searchPanelIsObject: boolean;
    id: string;
    protected formPanelService: FormPanelService;
    protected _cdr: ChangeDetectorRef;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutItemBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutItemBaseComponent, "bnrc-layout-item-base", never, { "config": { "alias": "config"; "required": false; }; "isPanel": { "alias": "isPanel"; "required": false; }; "maxLabelWidth": { "alias": "maxLabelWidth"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LayoutPanelBaseComponent extends LayoutItemBaseComponent implements OnInit {
    parentDom: HTMLElement;
    isPanel: boolean;
    config: LayoutSetting;
    maxLabelWidth$: Observable<number>;
    isSearchPanel: boolean;
    id: string;
    layoutControlCount: number;
    protected portalService: PortalService;
    protected layoutService: LayoutService;
    constructor();
    ngOnInit(): void;
    protected _calcWidth(config: any): void;
    protected _setLabelWidth(item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutPanelBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutPanelBaseComponent, "bnrc-layout-panel-base", never, { "parentDom": { "alias": "parentDom"; "required": false; }; "isPanel": { "alias": "isPanel"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PageBaseComponent extends ContainerComponent implements AfterViewInit {
    portalData$: Observable<PortalDataModel>;
    portalSubscription: Subscription;
    isRoot: boolean;
    hasRouterOutlet: PlaceHolderDataModel;
    hasRoute: boolean;
    fullscreen: boolean;
    pageData: PageDataModel | null;
    ngAfterViewInit(): void;
    protected addModulesToDom(): void;
    protected getData$(): Observable<PortalDataModel | null>;
    protected renderPlaceHolders(pageData: PageDataModel | null): void;
    protected preparePlaceholder(placeHolderElement: HTMLElement | DocumentFragment, placeHolderName: string, pageData: PageDataModel | null): void;
    protected getModuleControlUi(component: any): any;
    protected addModulesToPage(modules: Array<any>): void;
    protected getComponentFactory(uiComponent: {
        Selector: string;
        Name: string;
        Module: string;
        ModuleFileName: string;
    }): Observable<ComponentRef<any>>;
    protected getPlaceHolders(pageData: any): Array<PlaceHolderDataModel>;
    protected getModules(pageData: any): Array<ModuleDataModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageBaseComponent, "bnrc-page-base", never, {}, {}, never, never, false, never>;
}

declare class NumberBaseComponent extends FieldBaseComponent implements OnInit, OnDestroy {
    hasMask: boolean;
    tickRef: any;
    protected inputElement: HTMLInputElement | null | undefined;
    get decimalPrecision(): number;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onKeyDown(e: any): void;
    onValueChange(e: any): void;
    protected _updateBySetting(): void;
    protected _configChaned(_: any): void;
    protected _setValue(value: any): void;
    protected _clearInterval(): void;
    protected _isCharacter(evt: any): boolean;
    protected _getFormated(val: any): string;
    protected _setCursorPosition(cursorPosition: any): void;
    protected _getMinusValue(isMinus: boolean, newVal: string | undefined): string;
    protected _syncInputElementValue(value: number, e: {
        target: any;
    }): void;
    private reFormatValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberBaseComponent, "bnrc-number-base", never, {}, {}, never, never, false, never>;
}

type ModuleWithDynamicComponents = Type<any> & {
    dynamicComponentsMap: Record<string, unknown>;
};

declare class FilesValidationHelper {
    _maxFileCount: number;
    _maxFileSize: number;
    _maxTotalFileSize: number;
    get maxFileCount(): number;
    set maxFileCount(val: number);
    get maxFileSize(): number;
    set maxFileSize(val: number);
    get maxTotalFileSize(): number;
    set maxTotalFileSize(val: number);
    constructor(maxFileCount: number, maxFileSize: number, maxTotalFileSize: number);
    validateFiles(files: File[]): boolean;
    private _validateSize;
    private _getKbSize;
    private _getMbSize;
}

declare const Common: any;
declare const Ul: any;
declare const Ui: any;
declare const Util: any;
declare const Bw: any;
declare const BBB: any;
declare const LoginAction: any;
declare const UlvMainCtrl: any;
declare const LoginFormUi: any;
declare const LoginFormData: any;
declare const LoginForm: any;
declare const Ext: any;
declare const Offline: any;
declare const GanttChartHelper: any;
declare class BarsaApi {
    static idGenerator: number;
    static get GanttChartHelper(): any;
    static get Offline(): any;
    static get Ext(): any;
    static get Common(): any;
    static get Util(): any;
    static get Ul(): any;
    static get Ui(): any;
    static get Bw(): any;
    static get BBB(): any;
    static get LoginForm(): any;
    static get LoginAction(): any;
    static get LoginFormUi(): any;
    static get LoginFormData(): any;
}

declare class ReportViewBaseComponent<T extends UiReportViewBaseSetting> extends BaseComponent implements OnInit {
    _reportView: boolean;
    _visibility: string | null;
    contextView: any;
    viewSetting: T;
    allColumns: any;
    isCheckList: boolean;
    simpleInlineEdit: boolean;
    inlineEditWithoutSelection: boolean;
    hideToolbar: boolean;
    hideTitle: boolean;
    toolbarButtons: MenuItem[];
    allChecked: boolean;
    moDataList: any;
    UlvMainCtrlr: TypeUlvMainCtrlr;
    access: DefaultCommandsAccess;
    groupby: any;
    selectedCount: any;
    conditionalFormats: any;
    parentHeight: number;
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    contextMenuItems: any[];
    columns: any;
    allowInlineEdit: any;
    secondaryColumns: any;
    popin: boolean;
    customFieldInfo: MetaobjectDataModel | any;
    hasSummary: boolean;
    layoutInfo: LayoutSetting;
    hasSelected: boolean;
    hideIcon: boolean;
    columnsCount: any;
    hideOpenIcon: boolean;
    openOnClick: boolean;
    typeDefId: string;
    reportId: string;
    listEditViewId: string;
    typeViewId: string;
    extraRelation: any;
    relationList: Array<RelationItemType>;
    disableResponsive: boolean;
    rowItem: TemplateRef<any>;
    mobileOrTablet: boolean;
    inDialog: boolean;
    isMultiSelect: boolean;
    fullscreen: boolean;
    hideSearchpanel: boolean;
    newInlineEditMo: MetaobjectDataModel | null;
    selectedMo: MetaobjectDataModel;
    inlineEditMode: boolean;
    onlyInlineEdit: boolean;
    rowHoverable: boolean;
    groupSummary: boolean;
    tlbButtons: any[];
    formSetting: FormSetting;
    disableOverflowContextMenu: boolean;
    rowActivable: boolean;
    contentDensity: ContentDensity;
    rtl: any;
    showOkCancelButtons: any;
    title: any;
    hasInlineDeleteButton: boolean;
    hasInlineEditButton: boolean;
    contextSetting: any;
    gridFreeColumnSizing: boolean;
    navigationArrow: string;
    cartableTemplates: {
        [key: string]: FormSetting;
    };
    cartableChildsMo: {
        [key: string]: MetaobjectDataModel;
    };
    pagingSetting: PagingSetting;
    columnSummary: EventEmitter<ColumnSummaryType>;
    escapeKey: EventEmitter<MetaobjectDataModel>;
    resetWorkflowState: EventEmitter<void>;
    deselectAll: EventEmitter<void>;
    editFormPanelCancel: EventEmitter<MetaobjectDataModel>;
    editFormPanelSave: EventEmitter<MetaobjectDataModel>;
    selectNextInlineRecord: EventEmitter<MetaobjectDataModel>;
    editFormPanelValueChange: EventEmitter<{
        mo: MetaobjectDataModel;
        fieldDbName?: string;
    }>;
    ulvCommandClick: EventEmitter<any>;
    sortAscending: EventEmitter<any>;
    workflowShareButtons: EventEmitter<ShareButtonsChoiceDef>;
    sortDescending: EventEmitter<any>;
    filter: EventEmitter<any>;
    executeToolbarButton: EventEmitter<{
        itemId: string;
        options?: any;
    }>;
    resetGridSettings: EventEmitter<void>;
    sortSettingsChange: EventEmitter<SortSetting[]>;
    rowCheck: EventEmitter<{
        mo: any;
        index: any;
        cause?: any;
        onlyCheck?: boolean;
    }>;
    rowClick: EventEmitter<{
        mo: any;
        index: any;
    }>;
    cartableFormClosed: EventEmitter<{
        mo: any;
        index: any;
    }>;
    createNewMo: EventEmitter<void>;
    updateMo: EventEmitter<MetaobjectDataModel>;
    expandClick: EventEmitter<MetaobjectDataModel>;
    trackBySelectedFn: EventEmitter<{
        index: any;
        record: any;
    }>;
    allCheckbox: EventEmitter<boolean>;
    mandatory: EventEmitter<boolean>;
    columnResized: EventEmitter<columnsResizedEventArgs>;
    hasDetailsInRow: EventEmitter<boolean>;
    set containerWidth(val: number);
    resizedByUser: boolean;
    elWidth: number;
    canView: boolean;
    fitWidth: boolean;
    firstSelectedMetaobject: MetaobjectDataModel;
    contextMenuWidth: number;
    fieldDict: Record<string, string>;
    actionList: any[];
    detailsColumns: ReportViewColumn[];
    detailsComponent: EjrayOlgo;
    rowIndicator: boolean;
    protected _titleCase: TitleCasePipe;
    protected _bbbTranslate: BbbTranslatePipe;
    protected _el: ElementRef<any>;
    protected _cdr: ChangeDetectorRef;
    protected _renderer2: Renderer2;
    protected _findColumnByDbName: FindColumnByDbNamePipe;
    protected _ulvMainService: UlvMainService;
    protected _portalService: PortalService;
    protected _uploadService?: UploadService | null | undefined;
    protected _groupByService?: GroupByService | null | undefined;
    protected _containerWidth: number;
    protected _firstVisible: boolean;
    private _singleClicked;
    get showViewButton(): boolean;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onVisibilityChange(e: any, ..._args: any[]): void;
    onDeselectAll(): void;
    onRowCheck(e: {
        mo: MetaobjectDataModel;
        index: number;
        onlyCheck?: boolean;
    }): void;
    onWorkflowShareButtons(e: ShareButtonsChoiceDef): void;
    onOlgoEvents(e: {
        title: string;
        data?: any;
    }): void;
    onRowClick({ mo, index }: {
        mo: any;
        index: any;
    }): void;
    onCartableFormClosed({ mo, index }: {
        mo: any;
        index: any;
    }): void;
    onExpandClick(mo: MetaobjectDataModel): void;
    onAllCheckbox(checked: any): void;
    onClearCheckbox(): void;
    onSelectNextInlineRecord(mo: any): void;
    onEditFormPanelSave(mo: any): void;
    onEditFormPanelCancel(mo: MetaobjectDataModel): void;
    onEscapeKey(mo: MetaobjectDataModel): void;
    onEditFormPanelValueChange(e: {
        mo: MetaobjectDataModel;
        fieldDbName?: string;
    }): void;
    onUlvCommand({ mo, index }: {
        mo: any;
        index: any;
    }): void;
    onSortAscending(column: any): void;
    onSortDescending(column: any): void;
    onFilter(column: any): void;
    onAction(commandBody: string): void;
    onDynamicComponentEvents(e: {
        title: string;
        data?: any;
    }, mo: MetaobjectDataModel, index: number): void;
    detectChanges(): void;
    _trackBySelectedFn(index: any, record: any): void;
    _trackByColumn(index: number, column: ReportViewColumn): string;
    _trackByRow(index: number, row: MetaobjectDataModel): string;
    protected onActionListClick(mo: MetaobjectDataModel, index: number, itemId: string): void;
    protected _createActionButtons(): any[];
    protected _containerWidthChanged(_: number): void;
    protected _setRowIndicator(columns: ReportViewColumn[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportViewBaseComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportViewBaseComponent<any>, "bnrc-report-view-base", never, { "contextView": { "alias": "contextView"; "required": false; }; "viewSetting": { "alias": "viewSetting"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "isCheckList": { "alias": "isCheckList"; "required": false; }; "simpleInlineEdit": { "alias": "simpleInlineEdit"; "required": false; }; "inlineEditWithoutSelection": { "alias": "inlineEditWithoutSelection"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; "hideTitle": { "alias": "hideTitle"; "required": false; }; "toolbarButtons": { "alias": "toolbarButtons"; "required": false; }; "allChecked": { "alias": "allChecked"; "required": false; }; "moDataList": { "alias": "moDataList"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; "access": { "alias": "access"; "required": false; }; "groupby": { "alias": "groupby"; "required": false; }; "selectedCount": { "alias": "selectedCount"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; "parentHeight": { "alias": "parentHeight"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "allowInlineEdit": { "alias": "allowInlineEdit"; "required": false; }; "secondaryColumns": { "alias": "secondaryColumns"; "required": false; }; "popin": { "alias": "popin"; "required": false; }; "customFieldInfo": { "alias": "customFieldInfo"; "required": false; }; "hasSummary": { "alias": "hasSummary"; "required": false; }; "layoutInfo": { "alias": "layoutInfo"; "required": false; }; "hasSelected": { "alias": "hasSelected"; "required": false; }; "hideIcon": { "alias": "hideIcon"; "required": false; }; "columnsCount": { "alias": "columnsCount"; "required": false; }; "hideOpenIcon": { "alias": "hideOpenIcon"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; "typeDefId": { "alias": "typeDefId"; "required": false; }; "reportId": { "alias": "reportId"; "required": false; }; "listEditViewId": { "alias": "listEditViewId"; "required": false; }; "typeViewId": { "alias": "typeViewId"; "required": false; }; "extraRelation": { "alias": "extraRelation"; "required": false; }; "relationList": { "alias": "relationList"; "required": false; }; "disableResponsive": { "alias": "disableResponsive"; "required": false; }; "rowItem": { "alias": "rowItem"; "required": false; }; "mobileOrTablet": { "alias": "mobileOrTablet"; "required": false; }; "inDialog": { "alias": "inDialog"; "required": false; }; "isMultiSelect": { "alias": "isMultiSelect"; "required": false; }; "fullscreen": { "alias": "fullscreen"; "required": false; }; "hideSearchpanel": { "alias": "hideSearchpanel"; "required": false; }; "newInlineEditMo": { "alias": "newInlineEditMo"; "required": false; }; "selectedMo": { "alias": "selectedMo"; "required": false; }; "inlineEditMode": { "alias": "inlineEditMode"; "required": false; }; "onlyInlineEdit": { "alias": "onlyInlineEdit"; "required": false; }; "rowHoverable": { "alias": "rowHoverable"; "required": false; }; "groupSummary": { "alias": "groupSummary"; "required": false; }; "tlbButtons": { "alias": "tlbButtons"; "required": false; }; "formSetting": { "alias": "formSetting"; "required": false; }; "disableOverflowContextMenu": { "alias": "disableOverflowContextMenu"; "required": false; }; "rowActivable": { "alias": "rowActivable"; "required": false; }; "contentDensity": { "alias": "contentDensity"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "showOkCancelButtons": { "alias": "showOkCancelButtons"; "required": false; }; "title": { "alias": "title"; "required": false; }; "hasInlineDeleteButton": { "alias": "hasInlineDeleteButton"; "required": false; }; "hasInlineEditButton": { "alias": "hasInlineEditButton"; "required": false; }; "contextSetting": { "alias": "contextSetting"; "required": false; }; "gridFreeColumnSizing": { "alias": "gridFreeColumnSizing"; "required": false; }; "navigationArrow": { "alias": "navigationArrow"; "required": false; }; "cartableTemplates": { "alias": "cartableTemplates"; "required": false; }; "cartableChildsMo": { "alias": "cartableChildsMo"; "required": false; }; "pagingSetting": { "alias": "pagingSetting"; "required": false; }; "containerWidth": { "alias": "containerWidth"; "required": false; }; }, { "columnSummary": "columnSummary"; "escapeKey": "escapeKey"; "resetWorkflowState": "resetWorkflowState"; "deselectAll": "deselectAll"; "editFormPanelCancel": "editFormPanelCancel"; "editFormPanelSave": "editFormPanelSave"; "selectNextInlineRecord": "selectNextInlineRecord"; "editFormPanelValueChange": "editFormPanelValueChange"; "ulvCommandClick": "ulvCommandClick"; "sortAscending": "sortAscending"; "workflowShareButtons": "workflowShareButtons"; "sortDescending": "sortDescending"; "filter": "filter"; "executeToolbarButton": "executeToolbarButton"; "resetGridSettings": "resetGridSettings"; "sortSettingsChange": "sortSettingsChange"; "rowCheck": "rowCheck"; "rowClick": "rowClick"; "cartableFormClosed": "cartableFormClosed"; "createNewMo": "createNewMo"; "updateMo": "updateMo"; "expandClick": "expandClick"; "trackBySelectedFn": "trackBySelectedFn"; "allCheckbox": "allCheckbox"; "mandatory": "mandatory"; "columnResized": "columnResized"; "hasDetailsInRow": "hasDetailsInRow"; }, never, never, false, never>;
}

declare class FormPropsBaseComponent extends BaseComponent implements OnInit {
    breadCrumbs: BreadCrumbInfo[] | null;
    toolbarVisible: boolean;
    toolbarItems: any[];
    layoutActions: any[];
    layoutActionsTemplateRef: TemplateRef<any>;
    layout94: any;
    settings: MetaobjectDataModel;
    workflowPanelUi: any;
    title: string;
    subtitle: string;
    description: string;
    facetList: any[];
    removeHeaderBorder: boolean;
    removeContentPadding: boolean;
    isMobile: boolean;
    avatar: any;
    rtl: boolean;
    mask: boolean;
    canSend: boolean;
    landscape: boolean;
    standalone: boolean;
    footerDesign: any;
    workflowButtons: any[];
    workflowButtonsComboMode: any;
    fieldDict: {
        [key: string]: string;
    } | undefined;
    contentDensity: any;
    deviceSize: 's' | 'm' | 'l' | 'xl';
    dirValue: 'rtl' | 'ltr';
    modernTabs: LayoutSetting[];
    mo: MetaobjectDataModel;
    events: EventEmitter<{
        title: string;
        data?: any;
    }>;
    protected _controlUiPipe: ControlUiPipe;
    protected _formPanelService: FormPanelService;
    protected _sanitizer: DomSanitizer;
    protected _cdr: ChangeDetectorRef;
    protected _renderer2: Renderer2;
    protected _vcr: ViewContainerRef;
    protected _factoryResolver: ComponentFactoryResolver;
    ngOnInit(): void;
    onEvents(title: string, data?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormPropsBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormPropsBaseComponent, "bnrc-form-props-base", never, { "breadCrumbs": { "alias": "breadCrumbs"; "required": false; }; "toolbarVisible": { "alias": "toolbarVisible"; "required": false; }; "toolbarItems": { "alias": "toolbarItems"; "required": false; }; "layoutActions": { "alias": "layoutActions"; "required": false; }; "layoutActionsTemplateRef": { "alias": "layoutActionsTemplateRef"; "required": false; }; "layout94": { "alias": "layout94"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "workflowPanelUi": { "alias": "workflowPanelUi"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "description": { "alias": "description"; "required": false; }; "facetList": { "alias": "facetList"; "required": false; }; "removeHeaderBorder": { "alias": "removeHeaderBorder"; "required": false; }; "removeContentPadding": { "alias": "removeContentPadding"; "required": false; }; "isMobile": { "alias": "isMobile"; "required": false; }; "avatar": { "alias": "avatar"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "canSend": { "alias": "canSend"; "required": false; }; "landscape": { "alias": "landscape"; "required": false; }; "standalone": { "alias": "standalone"; "required": false; }; "footerDesign": { "alias": "footerDesign"; "required": false; }; "workflowButtons": { "alias": "workflowButtons"; "required": false; }; "workflowButtonsComboMode": { "alias": "workflowButtonsComboMode"; "required": false; }; "fieldDict": { "alias": "fieldDict"; "required": false; }; "contentDensity": { "alias": "contentDensity"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "dirValue": { "alias": "dirValue"; "required": false; }; "modernTabs": { "alias": "modernTabs"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; }, { "events": "events"; }, never, never, false, never>;
}

declare class LinearListHelper {
    private _uploadService;
    private _filesValidationHelper;
    private _fieldDefId;
    uploading$: Observable<IUploadingState>;
    protected readonly _onDestroy$: Subject<void>;
    private _valueExtra$;
    private _loading$;
    private _delete$;
    private _newFileUploaded$;
    constructor(_uploadService: UploadService, _filesValidationHelper: FilesValidationHelper, _fieldDefId: string);
    get loading$(): Observable<boolean>;
    get valueExtra$(): Observable<ValueExtraType>;
    get delete$(): Observable<FileAttachmentInfo>;
    get newFileUploaded$(): Observable<FileAttachmentInfo>;
    init(fileAttachmentInfo: FileAttachmentInfo): void;
    cancel(fileAttachment: FileAttachmentInfo): void;
    retry(fileAttachment: FileAttachmentInfo): void;
    uploadToServer(files: File[], key?: string): void;
    destroy(): void;
    protected get _valueExtra(): ValueExtraType;
    protected _getFileValueExtra(fileId: any): UploadFileProps;
    protected _setIconAndImage(fileAttachment: FileAttachmentInfo, fileValueExtra: UploadFileProps): void;
    protected _setLoading(loading: boolean): void;
    protected _createFileAttachment(file: File, key?: string | null): any;
    protected uploadFile(fileAttachment: FileAttachmentInfo, key?: string): Observable<any>;
    protected _updateValue(fileAttachment: FileAttachmentInfo, res: any[]): void;
}
interface UploadFileProps {
    FileUrl?: string;
    cancelation$?: Subject<void>;
    binary?: any;
    UploadState?: string;
    Progress?: number;
    IsIcon?: boolean;
}
type ValueExtraType = {
    [key: string]: UploadFileProps;
};

declare class PageWithFormHandlerBaseComponent extends PageBaseComponent {
    formpanelCtrlr: any;
    isFirstPage: boolean;
    ShowFormPanelControl: (formpanelCtrlr: any) => void;
    ForceCloseChild: () => void;
    RefreshFormPanelControl: (formpanelCtrlr: any) => void;
    private _showFormPanel;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageWithFormHandlerBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageWithFormHandlerBaseComponent, "ng-component", never, { "ShowFormPanelControl": { "alias": "ShowFormPanelControl"; "required": false; }; "ForceCloseChild": { "alias": "ForceCloseChild"; "required": false; }; "RefreshFormPanelControl": { "alias": "RefreshFormPanelControl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FormPageBaseComponent extends ContainerComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {
    formPanelCtrlr: any;
    params: {
        moId: string;
        typeDefId: string;
        reportId: string;
        viewId: string;
    };
    formpanelCtrlrId: string;
    $resize: Subject<void>;
    protected _containerService: ContainerService | null;
    private _ro;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    _resize(): void;
    _handleResize(): void;
    hideAllPageContent(): void;
    removeLastHidePage(): void;
    ShowFormPanelControl: (formpanelCtrlr: any) => void;
    RefreshFormPanelControl: () => void;
    ForceCloseChild: () => void;
    ForceClose: () => void;
    onFormClose(): void;
    protected prepareIds(formpanelCtrlrId: string, params: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormPageBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormPageBaseComponent, "bnrc-form-page-base", never, { "formPanelCtrlr": { "alias": "formPanelCtrlr"; "required": false; }; "ShowFormPanelControl": { "alias": "ShowFormPanelControl"; "required": false; }; "RefreshFormPanelControl": { "alias": "RefreshFormPanelControl"; "required": false; }; "ForceCloseChild": { "alias": "ForceCloseChild"; "required": false; }; "ForceClose": { "alias": "ForceClose"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FormComponent extends BaseComponent implements OnInit, OnChanges, OnDestroy {
    params: FormComponentParams;
    customFormPanelUi: any;
    formPanelCtrl: any;
    UlvMainCtrlr: TypeUlvMainCtrlr;
    formPanelCtrlId: string;
    saveOnChange: boolean;
    inlineEditInReport: boolean;
    titleChanged: EventEmitter<string>;
    moChanged: EventEmitter<MetaobjectDataModel>;
    formClose: EventEmitter<any>;
    uiComponent: EventEmitter<any>;
    formRendered: EventEmitter<any>;
    bruleAction: EventEmitter<BruleActionMessage>;
    beforeTransition: EventEmitter<any>;
    afterTransition: EventEmitter<{
        error: any;
        result: any;
    }>;
    vcr: ViewContainerRef;
    uniqueId: string;
    uiFormComponent: WritableSignal<ComponentRef<any> | undefined>;
    protected cdr: ChangeDetectorRef;
    protected portalService: PortalService;
    protected injector: Injector;
    protected _activatedRoute: ActivatedRoute;
    protected _router: Router;
    protected _containerService: ContainerService | null;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    _handleSaveOnFieldValueChange(): void;
    appendForm(params: any): void;
    protected _handleBruleShowMessageAction(action: BruleActionMessage): void;
    private _renderFormPanelUi;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "bnrc-form", never, { "params": { "alias": "params"; "required": false; }; "customFormPanelUi": { "alias": "customFormPanelUi"; "required": false; }; "formPanelCtrl": { "alias": "formPanelCtrl"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; "formPanelCtrlId": { "alias": "formPanelCtrlId"; "required": false; }; "saveOnChange": { "alias": "saveOnChange"; "required": false; }; "inlineEditInReport": { "alias": "inlineEditInReport"; "required": false; }; }, { "titleChanged": "titleChanged"; "moChanged": "moChanged"; "formClose": "formClose"; "uiComponent": "uiComponent"; "formRendered": "formRendered"; "bruleAction": "bruleAction"; "beforeTransition": "beforeTransition"; "afterTransition": "afterTransition"; }, never, never, false, never>;
}

declare class FormPageComponent extends FormPageBaseComponent {
    formRef: FormComponent;
    formPanelCtrlr: any;
    sectionClass: boolean;
    absolutePageClass: boolean;
    moId: string;
    typeDefId: string;
    reportId: string;
    viewId: string;
    formpanelCtrlrId: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormPageComponent, "bnrc-form-page", never, { "formPanelCtrlr": { "alias": "formPanelCtrlr"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BaseColumnPropsComponent extends BaseComponent implements AfterViewInit, OnChanges {
    save: EventEmitter<any>;
    cancel: EventEmitter<any>;
    tab: EventEmitter<any>;
    changeToEditMode: EventEmitter<any>;
    allColumns: ReportViewColumn[];
    column: any;
    attachmentViewType: number;
    mo: MetaobjectDataModel;
    index: any;
    editMode: boolean;
    isMobile: boolean;
    customRowHeight: any;
    controlUi: LayoutSetting | null;
    formLayoutShowLabel: boolean;
    isChecked: boolean;
    isdirty: boolean;
    isNewInlineMo: boolean;
    layout94: LayoutSetting;
    detailsComponentSetting: UiReportViewBaseSetting;
    value: any;
    icon: any;
    rtl: boolean;
    cellEdit: boolean;
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    customComponent: EjrayOlgo | null;
    private _columnService;
    constructor();
    _callChangeToEditMode(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseColumnPropsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseColumnPropsComponent, "bnrc-base-column-props", never, { "allColumns": { "alias": "allColumns"; "required": false; }; "column": { "alias": "column"; "required": false; }; "attachmentViewType": { "alias": "attachmentViewType"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "index": { "alias": "index"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "isMobile": { "alias": "isMobile"; "required": false; }; "customRowHeight": { "alias": "customRowHeight"; "required": false; }; "controlUi": { "alias": "controlUi"; "required": false; }; "formLayoutShowLabel": { "alias": "formLayoutShowLabel"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "isdirty": { "alias": "isdirty"; "required": false; }; "isNewInlineMo": { "alias": "isNewInlineMo"; "required": false; }; "layout94": { "alias": "layout94"; "required": false; }; "detailsComponentSetting": { "alias": "detailsComponentSetting"; "required": false; }; "value": { "alias": "value"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "cellEdit": { "alias": "cellEdit"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "customComponent": { "alias": "customComponent"; "required": false; }; }, { "save": "save"; "cancel": "cancel"; "tab": "tab"; "changeToEditMode": "changeToEditMode"; }, never, never, false, never>;
}

declare class TilePropsComponent extends BaseComponent implements OnInit {
    parameters: MetaobjectDataModel;
    data: MetaobjectDataModel;
    context: FieldSetting;
    edit: boolean;
    deviceSize: AbbrevationDeviceSize;
    setToStorage: boolean;
    listMode: boolean;
    navigateBackOnClick: boolean;
    groupType: string;
    layoutInfo: LayoutSetting;
    hideClick: EventEmitter<any>;
    renameClick: EventEmitter<any>;
    protected _renderer2: Renderer2;
    protected _cdr: ChangeDetectorRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<TilePropsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TilePropsComponent, "bnrc-tile-base", never, { "parameters": { "alias": "parameters"; "required": false; }; "data": { "alias": "data"; "required": false; }; "context": { "alias": "context"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "setToStorage": { "alias": "setToStorage"; "required": false; }; "listMode": { "alias": "listMode"; "required": false; }; "navigateBackOnClick": { "alias": "navigateBackOnClick"; "required": false; }; "groupType": { "alias": "groupType"; "required": false; }; "layoutInfo": { "alias": "layoutInfo"; "required": false; }; }, { "hideClick": "hideClick"; "renameClick": "renameClick"; }, never, never, false, never>;
}

declare class FormFieldReportPageComponent extends BaseComponent implements OnInit, OnDestroy {
    containerRef: ViewContainerRef;
    sectionClass: boolean;
    absolutePageClass: boolean;
    loading$: Observable<boolean>;
    private _activatedRoute;
    private _portalService;
    private _injector;
    private _cdr;
    private _loadingSource;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _setLoading;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldReportPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldReportPageComponent, "bnrc-form-field-report-page.component", never, {}, {}, never, never, false, never>;
}

declare class EmptyPageComponent extends PageWithFormHandlerBaseComponent implements OnInit {
    _position: string | null;
    sectionClass: boolean;
    absolutePageClass: boolean;
    ismodal: boolean;
    settings: MetaobjectDataModel;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyPageComponent, "bnrc-empty-page", never, {}, {}, never, never, false, never>;
}

declare class MasterDetailsPageComponent extends PageWithFormHandlerBaseComponent implements OnInit {
    _position: string | null;
    sectionClass: boolean;
    absolutePageClass: boolean;
    ismodal: boolean;
    settings: UiMasterDetailsPageSettings;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MasterDetailsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MasterDetailsPageComponent, "bnrc-master-details-page", never, {}, {}, never, never, false, never>;
}
interface UiMasterDetailsPageSettings extends MetaobjectDataModel {
    DesktopDetailsRoute: MetaobjectDataModel;
    MobileDetailsRoute: MetaobjectDataModel;
}

declare class RedirectReportNavigatorCommandComponent extends BaseComponent {
    settings: MetaobjectDataModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedirectReportNavigatorCommandComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RedirectReportNavigatorCommandComponent, "bnrc-redirect-report-navigator-command", never, {}, {}, never, never, false, never>;
}

declare class PortalPageComponent extends PageWithFormHandlerBaseComponent {
    _routingService: RoutingService;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PortalPageComponent, "bnrc-portal-page", never, {}, {}, never, never, false, never>;
}

declare class PortalPageSidebarComponent extends PageBaseComponent {
    _routingService: RoutingService;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalPageSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PortalPageSidebarComponent, "bnrc-portal-page-sidebar", never, {}, {}, never, never, false, never>;
}

declare class NotFoundComponent extends BaseComponent {
    componentName: string;
    moduleName: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotFoundComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotFoundComponent, "bnrc-not-found", never, { "componentName": { "alias": "componentName"; "required": false; }; "moduleName": { "alias": "moduleName"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BaseDynamicComponent extends BaseComponent implements OnInit, OnDestroy, OnChanges {
    _container: ViewContainerRef;
    component: EjrayOlgo;
    value: any;
    events: EventEmitter<{
        title: string;
        data?: any;
    }>;
    _component: ComponentRef<any>;
    protected _vcr: ViewContainerRef;
    protected _cdr: ChangeDetectorRef;
    protected _portalService: PortalService;
    protected _injector: Injector;
    ngOnInit(): Promise<void>;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    protected _renderComponentInstance(): Promise<void>;
    protected setComponentInputs(): void;
    protected _destroyComponentInstance(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDynamicComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseDynamicComponent, "bnrc-dynamic-component", never, { "component": { "alias": "component"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "events": "events"; }, never, never, false, never>;
}

declare class DynamicFormComponent extends BaseDynamicComponent {
    breadCrumbs: BreadCrumbInfo[] | null;
    toolbarVisible: boolean;
    toolbarItems: any[];
    layoutActions: any[];
    layoutActionsTemplateRef: TemplateRef<any>;
    workflowButtons: any[];
    layout94: any;
    footerDesign: any;
    settings: MetaobjectDataModel;
    workflowPanelUi: any;
    title: string;
    subtitle: string;
    description: string;
    facetList: any[];
    removeHeaderBorder: boolean;
    removeContentPadding: boolean;
    isMobile: boolean;
    avatar: any;
    rtl: boolean;
    mask: boolean;
    mo: MetaobjectDataModel;
    contentDensity: any;
    deviceSize: 's' | 'm' | 'l' | 'xl';
    dirValue: 'rtl' | 'ltr';
    fieldDict: {
        [key: string]: string;
    } | undefined;
    modernTabs: LayoutSetting[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "bnrc-dynamic-form-component", never, { "breadCrumbs": { "alias": "breadCrumbs"; "required": false; }; "toolbarVisible": { "alias": "toolbarVisible"; "required": false; }; "toolbarItems": { "alias": "toolbarItems"; "required": false; }; "layoutActions": { "alias": "layoutActions"; "required": false; }; "layoutActionsTemplateRef": { "alias": "layoutActionsTemplateRef"; "required": false; }; "workflowButtons": { "alias": "workflowButtons"; "required": false; }; "layout94": { "alias": "layout94"; "required": false; }; "footerDesign": { "alias": "footerDesign"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "workflowPanelUi": { "alias": "workflowPanelUi"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "description": { "alias": "description"; "required": false; }; "facetList": { "alias": "facetList"; "required": false; }; "removeHeaderBorder": { "alias": "removeHeaderBorder"; "required": false; }; "removeContentPadding": { "alias": "removeContentPadding"; "required": false; }; "isMobile": { "alias": "isMobile"; "required": false; }; "avatar": { "alias": "avatar"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "contentDensity": { "alias": "contentDensity"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "dirValue": { "alias": "dirValue"; "required": false; }; "fieldDict": { "alias": "fieldDict"; "required": false; }; "modernTabs": { "alias": "modernTabs"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DynamicItemComponent extends BaseDynamicComponent {
    mo: MetaobjectDataModel;
    allColumns: ReportViewColumn[];
    moDataList: MetaobjectDataModel[];
    columns: ReportViewColumn[];
    column: ReportViewColumn;
    index: number;
    last: boolean;
    hideOpenIcon: boolean;
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    rtl: boolean;
    editMode: boolean;
    setting: UiReportViewBaseSetting;
    parameters?: MetaobjectDataModel;
    contextMenuItems: any[];
    canView: boolean;
    showRowNumber: boolean;
    rowNumber: string;
    formSetting: FormSetting;
    conditionalFormats: any;
    disableOverflowContextMenu: boolean;
    navigationArrow: string;
    isCheckList: boolean;
    fields: MetaobjectDataModel;
    isChecked: boolean;
    layout94$: Observable<any>;
    inlineEditMode: boolean;
    isNewInlineMo: boolean;
    allowInlineEdit: boolean;
    typeDefId: string;
    rowIndicator: boolean;
    rowIndicatorColor: string;
    UlvMainCtrlr: TypeUlvMainCtrlr;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicItemComponent, "bnrc-dynamic-item-component", never, { "mo": { "alias": "mo"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "moDataList": { "alias": "moDataList"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "column": { "alias": "column"; "required": false; }; "index": { "alias": "index"; "required": false; }; "last": { "alias": "last"; "required": false; }; "hideOpenIcon": { "alias": "hideOpenIcon"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "setting": { "alias": "setting"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "canView": { "alias": "canView"; "required": false; }; "showRowNumber": { "alias": "showRowNumber"; "required": false; }; "rowNumber": { "alias": "rowNumber"; "required": false; }; "formSetting": { "alias": "formSetting"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; "disableOverflowContextMenu": { "alias": "disableOverflowContextMenu"; "required": false; }; "navigationArrow": { "alias": "navigationArrow"; "required": false; }; "isCheckList": { "alias": "isCheckList"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "layout94$": { "alias": "layout94$"; "required": false; }; "inlineEditMode": { "alias": "inlineEditMode"; "required": false; }; "isNewInlineMo": { "alias": "isNewInlineMo"; "required": false; }; "allowInlineEdit": { "alias": "allowInlineEdit"; "required": false; }; "typeDefId": { "alias": "typeDefId"; "required": false; }; "rowIndicator": { "alias": "rowIndicator"; "required": false; }; "rowIndicatorColor": { "alias": "rowIndicatorColor"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BaseViewPropsComponent extends BaseComponent {
    detailsComponent?: EjrayOlgo;
    detailsColumns: ReportViewColumn[];
    detailsText: string;
    detailsTextFunction: string;
    moDataList: MetaobjectDataModel[];
    reportId: string;
    allColumns: any;
    hideOpenIcon: boolean;
    isCheckList: boolean;
    allChecked: boolean;
    canView: boolean;
    visibility: boolean;
    level: number;
    expanded: boolean;
    styleIndex: number[];
    parentExpanded: boolean;
    access: DefaultCommandsAccess;
    groupby: any;
    UlvMainCtrlr: any;
    conditionalFormats: any;
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    contextMenuItems: any[];
    columns: any;
    allowInlineEdit: any;
    secondaryColumns: any;
    popin: boolean;
    typeDefId: string;
    columnsCount: any;
    mobileOrTablet: boolean;
    containerWidth: number;
    newInlineEditMo: MetaobjectDataModel | null;
    inlineEditMode: boolean;
    onlyInlineEdit: boolean;
    rowHoverable: boolean;
    openOnClick: boolean;
    tlbButtons: any[];
    setting: any | null | undefined;
    parameters: MetaobjectDataModel;
    formSetting: any;
    disableOverflowContextMenu: boolean;
    rowActivable: boolean;
    contentDensity: any;
    rtl: boolean;
    showOkCancelButtons: any;
    title: any;
    isChecked: any;
    navigationArrow: string;
    resetWorkflowState: EventEmitter<void>;
    deselectAll: EventEmitter<void>;
    escapeKey: EventEmitter<MetaobjectDataModel>;
    rowCheck: EventEmitter<{
        mo: MetaobjectDataModel;
        index: number;
        onlyCheck?: boolean;
    }>;
    workflowShareButtons: EventEmitter<ShareButtonsChoiceDef>;
    rowClick: EventEmitter<{
        mo: MetaobjectDataModel;
        index: number;
    }>;
    ulvCommand: EventEmitter<{
        mo: MetaobjectDataModel;
        index: number;
    }>;
    editFormPanelCancel: EventEmitter<MetaobjectDataModel>;
    editFormPanelSave: EventEmitter<MetaobjectDataModel>;
    selectNextInlineRecord: EventEmitter<MetaobjectDataModel>;
    action: EventEmitter<string>;
    expandClick: EventEmitter<MetaobjectDataModel>;
    editFormPanelValueChange: EventEmitter<{
        mo: MetaobjectDataModel;
        fieldDbName?: string;
    }>;
    cartableFormClosed: EventEmitter<{
        mo: MetaobjectDataModel;
        index: number;
    }>;
    _trackByRow(index: number, row: MetaobjectDataModel): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseViewPropsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseViewPropsComponent, "bnrc-base-view-props", never, { "detailsComponent": { "alias": "detailsComponent"; "required": false; }; "detailsColumns": { "alias": "detailsColumns"; "required": false; }; "detailsText": { "alias": "detailsText"; "required": false; }; "detailsTextFunction": { "alias": "detailsTextFunction"; "required": false; }; "moDataList": { "alias": "moDataList"; "required": false; }; "reportId": { "alias": "reportId"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "hideOpenIcon": { "alias": "hideOpenIcon"; "required": false; }; "isCheckList": { "alias": "isCheckList"; "required": false; }; "allChecked": { "alias": "allChecked"; "required": false; }; "canView": { "alias": "canView"; "required": false; }; "visibility": { "alias": "visibility"; "required": false; }; "level": { "alias": "level"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "styleIndex": { "alias": "styleIndex"; "required": false; }; "parentExpanded": { "alias": "parentExpanded"; "required": false; }; "access": { "alias": "access"; "required": false; }; "groupby": { "alias": "groupby"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "allowInlineEdit": { "alias": "allowInlineEdit"; "required": false; }; "secondaryColumns": { "alias": "secondaryColumns"; "required": false; }; "popin": { "alias": "popin"; "required": false; }; "typeDefId": { "alias": "typeDefId"; "required": false; }; "columnsCount": { "alias": "columnsCount"; "required": false; }; "mobileOrTablet": { "alias": "mobileOrTablet"; "required": false; }; "containerWidth": { "alias": "containerWidth"; "required": false; }; "newInlineEditMo": { "alias": "newInlineEditMo"; "required": false; }; "inlineEditMode": { "alias": "inlineEditMode"; "required": false; }; "onlyInlineEdit": { "alias": "onlyInlineEdit"; "required": false; }; "rowHoverable": { "alias": "rowHoverable"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; "tlbButtons": { "alias": "tlbButtons"; "required": false; }; "setting": { "alias": "setting"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "formSetting": { "alias": "formSetting"; "required": false; }; "disableOverflowContextMenu": { "alias": "disableOverflowContextMenu"; "required": false; }; "rowActivable": { "alias": "rowActivable"; "required": false; }; "contentDensity": { "alias": "contentDensity"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "showOkCancelButtons": { "alias": "showOkCancelButtons"; "required": false; }; "title": { "alias": "title"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "navigationArrow": { "alias": "navigationArrow"; "required": false; }; }, { "resetWorkflowState": "resetWorkflowState"; "deselectAll": "deselectAll"; "escapeKey": "escapeKey"; "rowCheck": "rowCheck"; "workflowShareButtons": "workflowShareButtons"; "rowClick": "rowClick"; "ulvCommand": "ulvCommand"; "editFormPanelCancel": "editFormPanelCancel"; "editFormPanelSave": "editFormPanelSave"; "selectNextInlineRecord": "selectNextInlineRecord"; "action": "action"; "expandClick": "expandClick"; "editFormPanelValueChange": "editFormPanelValueChange"; "cartableFormClosed": "cartableFormClosed"; }, never, never, false, never>;
}

declare class BaseViewContentPropsComponent<T extends UiReportViewBaseSetting> extends BaseViewPropsComponent {
    moDataList: MetaobjectDataModel[];
    setting: T;
    actionListClick: EventEmitter<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseViewContentPropsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseViewContentPropsComponent<any>, "bnrc-base-view-content-props", never, { "moDataList": { "alias": "moDataList"; "required": false; }; "setting": { "alias": "setting"; "required": false; }; }, { "actionListClick": "actionListClick"; }, never, never, false, never>;
}

type ReasonToSave = 'TAB' | 'CTRL+ENTER' | 'CHECK_CHANGED' | 'ESC' | 'MOUSEDOWN_OUTSIDE' | 'NONE';
declare class BaseViewItemPropsComponent extends BaseViewPropsComponent implements OnInit, OnChanges {
    actionListClick: EventEmitter<string>;
    events: EventEmitter<{
        title: string;
        data?: any;
    }>;
    _cartableFormRef: FormComponent;
    checkboxComponent: EjrayOlgo;
    disableEllapsis: boolean;
    isslider: boolean;
    attachmentViewType: number;
    contextMenuOverflowText: string;
    detailsComponent?: EjrayOlgo;
    detailsColumns: ReportViewColumn[];
    detailsText: string;
    mo: MetaobjectDataModel;
    moDataListCount: number;
    index: number;
    last: boolean;
    isdirty: boolean;
    isChecked: boolean;
    hideDetailsText: boolean;
    showViewButton: boolean;
    isNewInlineMo: boolean;
    extraRelation: any;
    hideOpenIcon: boolean;
    inlineEditWithoutSelection: boolean;
    inDialog: boolean;
    isMobile: boolean;
    isMultiSelect: boolean;
    rowIndicator: boolean;
    groupSummary: boolean;
    isLastChildGroup: boolean;
    showRowNumber: boolean;
    rowNumber: string;
    coloringRow: boolean;
    noSaveInlineEditInServer: boolean;
    rowIndicatorColor: string;
    UlvMainCtrlr: TypeUlvMainCtrlr;
    fieldDict: Record<string, string>;
    actionList: any[];
    set serializedRelatedMo(val: string);
    set cartableTemplate(val: FormSetting);
    set cartableMo(val: MetaobjectDataModel);
    set cartableWorkflowData(val: string);
    hasError: boolean;
    _focusToFirstEidtableColumn: boolean;
    _lastEditableColumnIndex: number;
    inlineEditInReport: boolean;
    layout$: Observable<any>;
    formPanelCtrlr: any;
    saving: boolean;
    saved: boolean;
    rewriteLayout: boolean;
    hasCartableTemplate: boolean;
    cartableParams: {
        formSetting: FormSetting;
        moId: string;
        typeDefId: string | undefined;
        viewId: any;
        inDialog: boolean;
        loadActivityView: boolean;
    };
    workflowState: WritableSignal<{
        error: any;
        state: 'Pending' | 'Finish' | '';
    } | null>;
    bruleActionMessage: WritableSignal<BruleActionMessage | null>;
    protected _domSanitizer: DomSanitizer;
    protected _cdr: ChangeDetectorRef;
    protected _reportValuePipe: MoReportValuePipe;
    protected _parentFormPanelService: FormPanelService | null;
    protected _formPanelService: FormPanelService | null;
    protected _ulvMainService: UlvMainService | null;
    private _saveEditedMo$;
    private _formpanelValueChanged$;
    private _formPanelLoaded;
    private _cartableMo;
    private _cartableTemplate;
    private _cartableWorkflowData;
    private _serializedRelatedMo;
    constructor();
    private get _hasFormPanelService();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    OnCartableFormClick(e: any): void;
    onRowCheck(onlyCheck?: boolean): void;
    onRowClick(): void;
    onColumnChangeToEditMode(elDom: HTMLElement, index: number): void;
    onTabKeyDown(e: any, index: any): void;
    onEditFormPanelSave(_: any): void;
    onEditFormPanelCancel(_: any): void;
    onUlvCommand(): void;
    onAction(commandBody: string): void;
    onExpandClick(): void;
    onDynamicComponentEvents(e: {
        title: string;
        data?: any;
    }): void;
    onCartableFormClosed(): void;
    onCartableBruleAction(bruleAction: BruleActionMessage): void;
    onCartableAfterTansition(e: any): void;
    onCartableBeforeTansition(): void;
    onResetWorkflowState(): void;
    _trackByColumn(index: number, column: ReportViewColumn): string;
    protected _handleResetWorkflowState(): void;
    protected _resetBruleActionMessage(): void;
    protected _updateCartableMo(serializeMo: string): void;
    protected _createCartableParams(): void;
    protected _needToSave(): boolean;
    protected _checkfocusOutFromRow(_target: any): void;
    protected _rowCheck(onlyCheck?: boolean): void;
    protected _raiseWorkflowShareButtons(isChecked: boolean): void;
    protected _handleValueChange(_formPanelCtrl: any, fieldCtrlr: any): void;
    protected _syncMo(): Observable<void>;
    protected _getMoWithoutWrapper(syncWithFormpanelMo: MetaobjectDataModel): MetaobjectDataModel;
    protected _updateWithOriginalValues(source: MetaobjectDataModel, dest: MetaobjectDataModel): void;
    protected _raiseFormPanelValueChanged(): void;
    protected _handleBruleShowMessageAction(action: BruleActionMessage): void;
    protected _createFormPanelCtrlr(mo: MetaobjectDataModel, typeDefId: string): any;
    protected _loadAndCreateFormPanelCtrlr(): void;
    protected _resetSavingStates(): void;
    protected _setSavingState(err: any): void;
    protected _inlineEditSaveFormPanel(reason: any): Promise<{
        reason: ReasonToSave;
        succeed: boolean;
        saved: boolean;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseViewItemPropsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseViewItemPropsComponent, "bnrc-base-view-item-props", never, { "checkboxComponent": { "alias": "checkboxComponent"; "required": false; }; "disableEllapsis": { "alias": "disableEllapsis"; "required": false; }; "isslider": { "alias": "isslider"; "required": false; }; "attachmentViewType": { "alias": "attachmentViewType"; "required": false; }; "contextMenuOverflowText": { "alias": "contextMenuOverflowText"; "required": false; }; "detailsComponent": { "alias": "detailsComponent"; "required": false; }; "detailsColumns": { "alias": "detailsColumns"; "required": false; }; "detailsText": { "alias": "detailsText"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "moDataListCount": { "alias": "moDataListCount"; "required": false; }; "index": { "alias": "index"; "required": false; }; "last": { "alias": "last"; "required": false; }; "isdirty": { "alias": "isdirty"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "hideDetailsText": { "alias": "hideDetailsText"; "required": false; }; "showViewButton": { "alias": "showViewButton"; "required": false; }; "isNewInlineMo": { "alias": "isNewInlineMo"; "required": false; }; "extraRelation": { "alias": "extraRelation"; "required": false; }; "hideOpenIcon": { "alias": "hideOpenIcon"; "required": false; }; "inlineEditWithoutSelection": { "alias": "inlineEditWithoutSelection"; "required": false; }; "inDialog": { "alias": "inDialog"; "required": false; }; "isMobile": { "alias": "isMobile"; "required": false; }; "isMultiSelect": { "alias": "isMultiSelect"; "required": false; }; "rowIndicator": { "alias": "rowIndicator"; "required": false; }; "groupSummary": { "alias": "groupSummary"; "required": false; }; "isLastChildGroup": { "alias": "isLastChildGroup"; "required": false; }; "showRowNumber": { "alias": "showRowNumber"; "required": false; }; "rowNumber": { "alias": "rowNumber"; "required": false; }; "coloringRow": { "alias": "coloringRow"; "required": false; }; "noSaveInlineEditInServer": { "alias": "noSaveInlineEditInServer"; "required": false; }; "rowIndicatorColor": { "alias": "rowIndicatorColor"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; "fieldDict": { "alias": "fieldDict"; "required": false; }; "actionList": { "alias": "actionList"; "required": false; }; "serializedRelatedMo": { "alias": "serializedRelatedMo"; "required": false; }; "cartableTemplate": { "alias": "cartableTemplate"; "required": false; }; "cartableMo": { "alias": "cartableMo"; "required": false; }; "cartableWorkflowData": { "alias": "cartableWorkflowData"; "required": false; }; }, { "actionListClick": "actionListClick"; "events": "events"; }, never, never, false, never>;
}

declare class BaseItemContentPropsComponent<T extends UiReportViewBaseSetting> extends BaseComponent {
    events: EventEmitter<{
        title: string;
        data?: any;
    }>;
    mo: MetaobjectDataModel;
    allColumns: ReportViewColumn[];
    column: ReportViewColumn;
    index: number;
    styleIndex: number[];
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    rtl: boolean;
    editMode: boolean;
    setting: T;
    parameters: MetaobjectDataModel;
    contextMenuItems: any[];
    canView: boolean;
    conditionalFormats: any;
    disableOverflowContextMenu: boolean;
    navigationArrow: string;
    isCheckList: boolean;
    fields: MetaobjectDataModel;
    isChecked: boolean;
    hideOpenIcon: boolean;
    layout94$: Observable<any>;
    inlineEditMode: boolean;
    allowInlineEdit: boolean;
    isNewInlineMo: boolean;
    formSetting: FormSetting;
    typeDefId: string;
    UlvMainCtrlr: TypeUlvMainCtrlr;
    protected _rval: MoReportValuePipe;
    protected _findColumnPipe: FindColumnByDbNamePipe;
    protected _cdr: ChangeDetectorRef;
    protected _el: ElementRef<any>;
    protected _renderer2: Renderer2;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseItemContentPropsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseItemContentPropsComponent<any>, "bnrc-base-item-content-props", never, { "mo": { "alias": "mo"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "column": { "alias": "column"; "required": false; }; "index": { "alias": "index"; "required": false; }; "styleIndex": { "alias": "styleIndex"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "setting": { "alias": "setting"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "canView": { "alias": "canView"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; "disableOverflowContextMenu": { "alias": "disableOverflowContextMenu"; "required": false; }; "navigationArrow": { "alias": "navigationArrow"; "required": false; }; "isCheckList": { "alias": "isCheckList"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "hideOpenIcon": { "alias": "hideOpenIcon"; "required": false; }; "layout94$": { "alias": "layout94$"; "required": false; }; "inlineEditMode": { "alias": "inlineEditMode"; "required": false; }; "allowInlineEdit": { "alias": "allowInlineEdit"; "required": false; }; "isNewInlineMo": { "alias": "isNewInlineMo"; "required": false; }; "formSetting": { "alias": "formSetting"; "required": false; }; "typeDefId": { "alias": "typeDefId"; "required": false; }; "UlvMainCtrlr": { "alias": "UlvMainCtrlr"; "required": false; }; }, { "events": "events"; }, never, never, false, never>;
}

declare class BaseFormToolbaritemPropsComponent extends BaseComponent {
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    btn: any;
    context: any;
    isEnable: boolean;
    inlineEditMode: boolean;
    parameters: MetaobjectDataModel;
    ulvClick: EventEmitter<{
        title: string;
        data?: any;
    }>;
    mo: MetaobjectDataModel;
    allColumns: ReportViewColumn[];
    index: number;
    showText: boolean;
    conditionalFormats: any;
    commandClick: EventEmitter<any>;
    protected _reportValuePipe: MoReportValuePipe;
    protected _cdr: ChangeDetectorRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormToolbaritemPropsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormToolbaritemPropsComponent, "bnrc-form-toolbaritem-props", never, { "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "btn": { "alias": "btn"; "required": false; }; "context": { "alias": "context"; "required": false; }; "isEnable": { "alias": "isEnable"; "required": false; }; "inlineEditMode": { "alias": "inlineEditMode"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "index": { "alias": "index"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; }, { "ulvClick": "ulvClick"; "commandClick": "commandClick"; }, never, never, false, never>;
}

declare class DynamicFormToolbaritemComponent extends BaseDynamicComponent {
    btnClick: EventEmitter<any>;
    mo: MetaobjectDataModel;
    index: number;
    deviceName: DeviceSize;
    deviceSize: AbbrevationDeviceSize;
    context: any;
    btn: any;
    isEnable: boolean;
    showText: boolean;
    allColumns: ReportViewColumn[];
    conditionalFormats: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormToolbaritemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormToolbaritemComponent, "bnrc-dynamic-form-toolbaritem", never, { "mo": { "alias": "mo"; "required": false; }; "index": { "alias": "index"; "required": false; }; "deviceName": { "alias": "deviceName"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "context": { "alias": "context"; "required": false; }; "btn": { "alias": "btn"; "required": false; }; "isEnable": { "alias": "isEnable"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "allColumns": { "alias": "allColumns"; "required": false; }; "conditionalFormats": { "alias": "conditionalFormats"; "required": false; }; }, { "btnClick": "btnClick"; }, never, never, false, never>;
}

declare class DynamicLayoutComponent extends BaseDynamicComponent {
    selector: string;
    module: string;
    name: string;
    parameters: MetaobjectDataModel;
    moduleFileName: string;
    flex: string;
    config: LayoutSetting;
    maxLabelWidth: number;
    hasHorizontalText: boolean;
    isSearchPanel: boolean;
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicLayoutComponent, "bnrc-dynamic-layout", never, { "selector": { "alias": "selector"; "required": false; }; "module": { "alias": "module"; "required": false; }; "name": { "alias": "name"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "moduleFileName": { "alias": "moduleFileName"; "required": false; }; "flex": { "alias": "flex"; "required": false; }; "config": { "alias": "config"; "required": false; }; "maxLabelWidth": { "alias": "maxLabelWidth"; "required": false; }; "hasHorizontalText": { "alias": "hasHorizontalText"; "required": false; }; "isSearchPanel": { "alias": "isSearchPanel"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DynamicTileGroupComponent extends BaseDynamicComponent {
    appTileGroup: MetaobjectDataModel;
    tabRef: any;
    stackContent: boolean;
    cssStyles: string;
    edit: boolean;
    rtl: boolean;
    isAppTileSubGroup: boolean | undefined;
    deviceSize: AbbrevationDeviceSize;
    isLast: boolean;
    tilesDropped: EventEmitter<{
        appTileGroup: MetaobjectDataModel;
        event: CdkDragDrop<{
            isTile: boolean;
            items: MetaobjectDataModel[];
        }>;
    }>;
    hideAppTileClick: EventEmitter<MetaobjectDataModel>;
    renameAppTileClick: EventEmitter<MetaobjectDataModel>;
    toggleGroup: EventEmitter<MetaobjectDataModel>;
    resetGroup: EventEmitter<MetaobjectDataModel>;
    deleteGroup: EventEmitter<MetaobjectDataModel>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTileGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicTileGroupComponent, "bnrc-dynamic-tile-group,[dynamictilegroup]", never, { "appTileGroup": { "alias": "appTileGroup"; "required": false; }; "tabRef": { "alias": "tabRef"; "required": false; }; "stackContent": { "alias": "stackContent"; "required": false; }; "cssStyles": { "alias": "cssStyles"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "isAppTileSubGroup": { "alias": "isAppTileSubGroup"; "required": false; }; "deviceSize": { "alias": "deviceSize"; "required": false; }; "isLast": { "alias": "isLast"; "required": false; }; }, { "tilesDropped": "tilesDropped"; "hideAppTileClick": "hideAppTileClick"; "renameAppTileClick": "renameAppTileClick"; "toggleGroup": "toggleGroup"; "resetGroup": "resetGroup"; "deleteGroup": "deleteGroup"; }, never, never, false, never>;
}

declare class RootPortalComponent extends PageBaseComponent implements OnInit {
    sectionRef: ElementRef;
    footerRefVcr: ViewContainerRef;
    _dir: string;
    _deviceSize: any;
    portalLoading$: Observable<boolean>;
    modules: any;
    isRoot: boolean;
    inLocalMode: boolean;
    hasOverlay: boolean;
    imageUrl: string;
    backgroundColor: string;
    shellbarHeight$: Observable<string>;
    ngOnInit(): void;
    protected onSendOfflineDataToServer(): void;
    protected onRemoveOfflineDataAndReturnToOnline(): void;
    protected onRemoveOfflineData(): void;
    protected addFooter(pageData: PageDataModel | null): void;
    protected renderPlaceHolders(pageData: PageDataModel | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RootPortalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RootPortalComponent, "bnrc-root-portal", never, {}, {}, never, never, false, never>;
}

declare class AnchorScrollDirective {
    anchorScroll: string;
    scrollInto(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorScrollDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorScrollDirective, "[anchorScroll]", never, { "anchorScroll": { "alias": "anchorScroll"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class BaseDirective implements OnInit, AfterViewInit, AfterContentInit, OnDestroy, OnChanges {
    protected _el: ElementRef<any>;
    protected _portalService: PortalService;
    protected _renderer2: Renderer2;
    protected readonly _onDestroy$: Subject<void>;
    get renderer2(): Renderer2;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseDirective, never, never, {}, {}, never, never, true, never>;
}

declare class AttrRtlDirective extends BaseDirective {
    rtl: boolean | undefined;
    constructor();
    private _setRtlAttribute;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttrRtlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AttrRtlDirective, "[attrRtl]", never, { "rtl": { "alias": "attrRtl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ColumnResizerDirective extends BaseDirective implements OnInit {
    disableResizer: boolean;
    private renderer;
    ngOnInit(): void;
    private _addColumnsResizer;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnResizerDirective, "[columnResizer]", never, { "disableResizer": { "alias": "disableResizer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DynamicCommandDirective {
    dynCommand: MetaobjectDataModel;
    mo: MetaobjectDataModel;
    enableCommand: any;
    commandClick: EventEmitter<any>;
    onClick(event: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicCommandDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicCommandDirective, "[dynCommand]", never, { "dynCommand": { "alias": "dynCommand"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "enableCommand": { "alias": "enableCommand"; "required": false; }; }, { "commandClick": "commandClick"; }, never, never, false, never>;
}

declare class EllipsifyDirective extends BaseDirective implements AfterViewInit {
    limitLine: any;
    childes: ElementRef[];
    protected renderer: Renderer2;
    moseMove(e: any): void;
    ngAfterViewInit(): void;
    private _heightChange;
    private _initStyle;
    private _handleNoEllipsis;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsifyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EllipsifyDirective, "[ellipsify]", never, { "limitLine": { "alias": "limitLine"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FieldDirective {
    field: string;
    value: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FieldDirective, "[field]", never, { "field": { "alias": "field"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ImageLazyDirective extends BaseDirective implements OnInit {
    auto: boolean;
    threshold: number;
    imageLoaded: EventEmitter<any>;
    imgLazy: string;
    protected _el: ElementRef;
    private portalService;
    private _imgEl;
    private _imageViewed$;
    constructor();
    ngOnInit(): void;
    showImage(): void;
    private handleLoadEvent;
    private isInViewport;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLazyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageLazyDirective, "[imgLazy]", never, { "auto": { "alias": "auto"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "imgLazy": { "alias": "imgLazy"; "required": false; }; }, { "imageLoaded": "imageLoaded"; }, never, never, false, never>;
}

declare enum IntersectionStatus {
    Visible = "Visible",
    Pending = "Pending",
    NotVisible = "NotVisible"
}
declare const fromIntersectionObserver: (element: HTMLElement, config: IntersectionObserverInit, debounce?: number, autoStop?: boolean) => Observable<IntersectionStatus>;

declare class IntersectionObserverDirective implements OnInit, OnDestroy {
    intersectionDebounce: number;
    intersectionRootMargin: string;
    intersectionRoot: HTMLElement;
    intersectionThreshold: number | number[];
    visibilityChange: EventEmitter<IntersectionStatus>;
    private element;
    private destroy$;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IntersectionObserverDirective, "[intersectionObserver]", never, { "intersectionDebounce": { "alias": "intersectionDebounce"; "required": false; }; "intersectionRootMargin": { "alias": "intersectionRootMargin"; "required": false; }; "intersectionRoot": { "alias": "intersectionRoot"; "required": false; }; "intersectionThreshold": { "alias": "intersectionThreshold"; "required": false; }; }, { "visibilityChange": "visibilityChange"; }, never, never, false, never>;
}

declare class ItemsRendererDirective extends BaseDirective implements OnInit {
    itemsRenderer: any;
    moDataList: MetaobjectDataModel[];
    itemClass: string;
    itemClick: EventEmitter<any>;
    handleClick: boolean;
    private _fragmentDoc;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItemsRendererDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemsRendererDirective, "[itemsRenderer]", never, { "itemsRenderer": { "alias": "itemsRenderer"; "required": false; }; "moDataList": { "alias": "moDataList"; "required": false; }; "itemClass": { "alias": "itemClass"; "required": false; }; "handleClick": { "alias": "handleClick"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, false, never>;
}

declare class NumbersOnlyInputDirective {
    private elRef;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    onInputChange(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumbersOnlyInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumbersOnlyInputDirective, "input[type=number], input[numbersOnly]", never, {}, {}, never, never, false, never>;
}

declare class PlaceHolderDirective {
    placeHolder: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlaceHolderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PlaceHolderDirective, "[placeHolder]", never, { "placeHolder": { "alias": "placeHolder"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RenderUlvViewerDirective extends BaseDirective implements AfterViewInit, OnDestroy {
    mask: boolean;
    isReportPage: boolean;
    layoutInfo: LayoutSetting;
    viewer: any;
    component: ComponentRef<any>;
    private _injector;
    private _vcr;
    private _cdr;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    _render(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderUlvViewerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderUlvViewerDirective, "[renderUlvViewer]", never, { "mask": { "alias": "mask"; "required": false; }; "isReportPage": { "alias": "isReportPage"; "required": false; }; "layoutInfo": { "alias": "layoutInfo"; "required": false; }; "viewer": { "alias": "renderUlvViewer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RenderUlvPaginDirective extends BaseDirective implements OnInit, OnDestroy {
    pageChange: EventEmitter<number>;
    mask: boolean;
    pagingSetting: PagingSetting;
    context: any;
    component: ComponentRef<any>;
    private _injector;
    private _vcr;
    private _cdr;
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    _render(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderUlvPaginDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderUlvPaginDirective, "[renderUlvPaging]", never, { "mask": { "alias": "mask"; "required": false; }; "pagingSetting": { "alias": "pagingSetting"; "required": false; }; "context": { "alias": "renderUlvPaging"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, false, never>;
}

declare class TableResizerDirective extends BaseDirective implements OnInit, OnDestroy, AfterViewInit, OnChanges {
    fitWidth: boolean;
    minWidth: any;
    minHeight: any;
    containerWidth: number;
    rowResizer: boolean;
    enableResizing: boolean;
    columnResized: EventEmitter<ColumnResizedArgs[]>;
    private renderer;
    private _currentCell;
    private _sideCell;
    private _startX;
    private _startY;
    private _currentColumnWidth;
    private _sideColumnWidth;
    private _currentRowHeight;
    private _currentResizer;
    private _isInitTable;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    private get _table();
    moseDown(e: any): void;
    moseMove(e: any): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private _initializeTable;
    private _resizeRow;
    private _resizeColumn;
    private _addRowsResizer;
    private _putBodyCellsContentIntoDiv;
    private _getSideCell;
    private _changeWidth;
    private _changeHeight;
    private _initTable;
    private _setTableMode;
    private _setTableFreeSize;
    private _setTableFitSize;
    private _mouseDown;
    private _mouseMove;
    private _mouseUp;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableResizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableResizerDirective, "[tableResizer]", never, { "fitWidth": { "alias": "fitWidth"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "containerWidth": { "alias": "containerWidth"; "required": false; }; "rowResizer": { "alias": "rowResizer"; "required": false; }; "enableResizing": { "alias": "enableResizing"; "required": false; }; }, { "columnResized": "columnResized"; }, never, never, false, never>;
}

declare class UlvCommandDirective extends BaseDirective {
    ulvCommandHandler: any;
    disable: boolean;
    commandClick: EventEmitter<any>;
    onClick(event: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<UlvCommandDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UlvCommandDirective, "[ulvCommandHandler]", never, { "ulvCommandHandler": { "alias": "ulvCommandHandler"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; }, { "commandClick": "commandClick"; }, never, never, false, never>;
}

declare class UntilInViewDirective extends BaseDirective implements OnInit, OnDestroy {
    untilInView: ElementRef;
    intersectionDebounce: number;
    private _templateRef;
    private _vcr;
    private _cdr;
    private viewed$;
    viewed(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UntilInViewDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UntilInViewDirective, "[untilInView]", never, { "untilInView": { "alias": "untilInView"; "required": false; }; "intersectionDebounce": { "alias": "intersectionDebounce"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WorfkflowwChoiceCommandDirective {
    wfChoice: ChoiceDef;
    mo: MetaobjectDataModel;
    enableCommand: any;
    commandClick: EventEmitter<any>;
    workflowExecuteChoiceStatusChanged: EventEmitter<WorkflowExecuteChoiceStatus>;
    status: WorkflowExecuteChoiceStatus;
    onClick(event: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorfkflowwChoiceCommandDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WorfkflowwChoiceCommandDirective, "[wfChoice]", never, { "wfChoice": { "alias": "wfChoice"; "required": false; }; "mo": { "alias": "mo"; "required": false; }; "enableCommand": { "alias": "enableCommand"; "required": false; }; }, { "commandClick": "commandClick"; "workflowExecuteChoiceStatusChanged": "workflowExecuteChoiceStatusChanged"; }, never, never, false, never>;
}

interface ToastService {
    open(msg: any, option?: any): any;
}

declare class CopyDirective extends BaseDirective implements OnInit {
    copy: string;
    _inputEl: HTMLInputElement;
    protected _toastService: ToastService | null;
    /**
     *
     */
    constructor();
    doCopy(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CopyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyDirective, "[copy]", never, { "copy": { "alias": "copy"; "required": false; }; }, {}, never, never, false, never>;
}

declare class EllapsisTextDirective extends BaseDirective implements AfterViewInit {
    ellapsisText: string;
    fontSize: string;
    disableEllapsis: boolean;
    ellapsised: EventEmitter<boolean>;
    _widthChange$: Subject<number>;
    myObserver: ResizeObserver;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    protected _checkEllapsised(): void;
    protected _isEllipsisActive(element: HTMLElement): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllapsisTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EllapsisTextDirective, "[ellapsisText]", never, { "ellapsisText": { "alias": "ellapsisText"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "disableEllapsis": { "alias": "disableEllapsis"; "required": false; }; }, { "ellapsised": "ellapsised"; }, never, never, false, never>;
}

declare class FillEmptySpaceDirective extends BaseDirective implements AfterViewInit {
    containerDom: HTMLElement;
    decrement: string;
    disable: boolean;
    height?: number;
    dontUseTopBound: boolean;
    setMinHeight: boolean;
    heightChanged: EventEmitter<any>;
    _height: string;
    topBound: string;
    oldTopBound: string;
    ngAfterViewInit(): void;
    Refresh(): void;
    private _setHeightOfFormContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<FillEmptySpaceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FillEmptySpaceDirective, "[fillEmptySpace]", ["fillEmptySpace"], { "containerDom": { "alias": "containerDom"; "required": false; }; "decrement": { "alias": "decrement"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "height": { "alias": "height"; "required": false; }; "dontUseTopBound": { "alias": "dontUseTopBound"; "required": false; }; "setMinHeight": { "alias": "setMinHeight"; "required": false; }; }, { "heightChanged": "heightChanged"; }, never, never, false, never>;
}

declare class FormCloseDirective extends BaseDirective implements AfterViewInit {
    isMobile: boolean;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormCloseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormCloseDirective, "[formClose]", never, { "isMobile": { "alias": "isMobile"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MobileDirective extends BaseDirective implements OnInit {
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MobileDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MobileDirective, "[mobile]", never, {}, {}, never, never, false, never>;
}

declare class BodyClickDirective extends BaseDirective {
    disableBodyClick: boolean;
    protected _document: Document;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BodyClickDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BodyClickDirective, "[bodyClick]", never, { "disableBodyClick": { "alias": "disableBodyClick"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PreventDefaultDirective extends BaseDirective {
    onClick(e: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreventDefaultDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventDefaultDirective, "[preventDefault]", never, {}, {}, never, never, false, never>;
}

declare class StopPropagationDirective extends BaseDirective {
    onClick(e: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StopPropagationDirective, "[stopPropagation]", never, {}, {}, never, never, false, never>;
}

declare class CountDownDirective extends BaseDirective {
    value: Date;
    includeMonth: boolean;
    includeDay: boolean;
    includeHour: boolean;
    includeMinute: boolean;
    expired: EventEmitter<void>;
    countDownText: string;
    _interval: any;
    protected _dateService: DateService;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    protected _setCountDown(value: Date): void;
    private clearInterval;
    private _getMonthText;
    private _daysText;
    private _getTimeText;
    static ɵfac: i0.ɵɵFactoryDeclaration<CountDownDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CountDownDirective, "[countDown]", never, { "value": { "alias": "countDown"; "required": false; }; "includeMonth": { "alias": "includeMonth"; "required": false; }; "includeDay": { "alias": "includeDay"; "required": false; }; "includeHour": { "alias": "includeHour"; "required": false; }; "includeMinute": { "alias": "includeMinute"; "required": false; }; }, { "expired": "expired"; }, never, never, false, never>;
}

declare class RouteFormChangeDirective extends BaseDirective {
    handleBodyClick: boolean;
    stateChanged: EventEmitter<any>;
    private _router;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RouteFormChangeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RouteFormChangeDirective, "[routeFormChange]", never, { "handleBodyClick": { "alias": "handleBodyClick"; "required": false; }; }, { "stateChanged": "stateChanged"; }, never, never, false, never>;
}

declare class DynamicStyleDirective extends BaseDirective {
    cssStyle: string | undefined;
    id: string;
    private _style;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    protected _addDynamicFormStyles(cssStyles: string | undefined): void;
    protected _removeDynamicFormStyles(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicStyleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicStyleDirective, "[cssStyle]", never, { "cssStyle": { "alias": "cssStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NowraptextDirective extends BaseDirective {
    width: string;
    _renderer2: Renderer2;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NowraptextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NowraptextDirective, "[nowraptext]", never, { "width": { "alias": "width"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LabelmandatoryDirective extends BaseDirective {
    lblMandatory: boolean;
    mandatoryStyle: string;
    protected _el: ElementRef;
    protected _document: Document;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    _checkStar(mandatory: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelmandatoryDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelmandatoryDirective, "[lblMandatory]", never, { "lblMandatory": { "alias": "lblMandatory"; "required": false; }; "mandatoryStyle": { "alias": "mandatoryStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AbsoluteDivBodyDirective extends BaseDirective implements AfterViewInit {
    elemCreated: EventEmitter<any>;
    id: string;
    elem: HTMLDivElement;
    ngOnInit(): void;
    _appendDivToBody(): void;
    _getEl(): HTMLElement | null;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbsoluteDivBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbsoluteDivBodyDirective, "[absDiv]", never, {}, { "elemCreated": "elemCreated"; }, never, never, false, never>;
}

declare class LoadExternalFilesDirective implements OnInit {
    _renderer2: Renderer2;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadExternalFilesDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LoadExternalFilesDirective, "[loadExternalFiles]", never, {}, {}, never, never, false, never>;
}

declare class RenderUlvDirective extends BaseDirective implements AfterViewInit, OnDestroy {
    reportId: i0.InputSignal<string | undefined>;
    component: ComponentRef<any>;
    private _logService;
    private _injector;
    private _vcr;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    _render(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderUlvDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderUlvDirective, "[renderUlv]", never, { "reportId": { "alias": "reportId"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class PrintFilesDirective {
    files: FileAttachmentInfo[];
    file: FileAttachmentInfo;
    isImageGallery: boolean;
    component: Type<any>;
    constructor();
    _handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrintFilesDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PrintFilesDirective, "[printFiles]", never, { "files": { "alias": "files"; "required": false; }; "file": { "alias": "file"; "required": false; }; "isImageGallery": { "alias": "isImageGallery"; "required": false; }; "component": { "alias": "component"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SaveImageDirective {
    name: string;
    src: string;
    _handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SaveImageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SaveImageDirective, "[saveImage]", never, { "name": { "alias": "name"; "required": false; }; "src": { "alias": "src"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WebOtpDirective implements OnDestroy {
    otpRecieved: EventEmitter<string>;
    autoUpdate: boolean;
    private _ac;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebOtpDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WebOtpDirective, "[appWebotp]", never, { "autoUpdate": { "alias": "autoUpdate"; "required": false; }; }, { "otpRecieved": "otpRecieved"; }, never, never, false, never>;
}

declare class SplideSliderDirective extends BaseDirective {
    _width: any;
    moDataList: MetaobjectDataModel[];
    type: SliderType;
    breakpoint991: number;
    breakpoint768: number;
    breakpoint480: number;
    breakpoint1279: number;
    sliderPerPage: number;
    sliderGap: number;
    sliderPadding: number;
    width: string;
    carouselCls: string;
    numWidth: number;
    height: number;
    get dom(): HTMLElement;
    _splide: undefined | any;
    rval: MoReportValuePipe;
    protected readonly _picFieldSrc: PictureFieldSourcePipe;
    protected readonly _renderer2: Renderer2;
    protected readonly _el: ElementRef<any>;
    protected readonly _portalService: PortalService;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onRefresh(): void;
    _refreshSplide(): void;
    _init(): void;
    get _getCommonOptions(): Record<string, any>;
    get direction(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplideSliderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SplideSliderDirective, "[splideSlider]", never, { "moDataList": { "alias": "moDataList"; "required": false; }; "type": { "alias": "type"; "required": false; }; "breakpoint991": { "alias": "breakpoint991"; "required": false; }; "breakpoint768": { "alias": "breakpoint768"; "required": false; }; "breakpoint480": { "alias": "breakpoint480"; "required": false; }; "breakpoint1279": { "alias": "breakpoint1279"; "required": false; }; "sliderPerPage": { "alias": "sliderPerPage"; "required": false; }; "sliderGap": { "alias": "sliderGap"; "required": false; }; "sliderPadding": { "alias": "sliderPadding"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, never, false, never>;
}
type SliderType = 'full' | 'multiple' | 'single' | 'small' | undefined;

declare class DynamicRootVariableDirective extends BaseDirective {
    cssVariableName: string;
    cssVariableValue: string | undefined;
    disable: boolean | undefined;
    private _style;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    refresh(): void;
    protected _addDynamicFormStyles(cssVariableName: string, cssVariableValue: any): void;
    protected _removeDynamicFormStyles(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicRootVariableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicRootVariableDirective, "[cssRootVariable]", ["cssRootVariable"], { "cssVariableName": { "alias": "cssVariableName"; "required": false; }; "cssVariableValue": { "alias": "cssVariableValue"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HorizontalResponsiveDirective extends BaseDirective {
    disable: boolean;
    config: LayoutSetting;
    hrResponsive: UiResponsiveSettings | undefined;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    protected _addDynamicFormStyles(hResponsive: UiResponsiveSettings | undefined): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HorizontalResponsiveDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HorizontalResponsiveDirective, "[hrResponsive]", never, { "disable": { "alias": "disable"; "required": false; }; "config": { "alias": "config"; "required": false; }; "hrResponsive": { "alias": "hrResponsive"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MeasureFormTitleWidthDirective extends BaseDirective implements OnInit {
    mWidthTitle: string;
    enableMobile: boolean;
    private ismobile;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    _addClass(title: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MeasureFormTitleWidthDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MeasureFormTitleWidthDirective, "[mWidthTitle]", never, { "mWidthTitle": { "alias": "mWidthTitle"; "required": false; }; "enableMobile": { "alias": "enableMobile"; "required": false; }; }, {}, never, never, false, never>;
}

declare class OverflowTextDirective extends BaseDirective {
    private _checkText$;
    private resizeObserver;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    isTextOverflowing(element: any): boolean;
    _checkOverflow(): void;
    _addOverflowTextClass(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OverflowTextDirective, "[overflowText]", ["overflowText"], {}, {}, never, never, false, never>;
}

declare class ShortcutRegisterDirective extends BaseDirective {
    shortcutRegister: ShortCutData[];
    shortcuts: ShortCuts;
    private _ulvMainService;
    ngOnInit(): void;
    private _initShortCuts;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortcutRegisterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShortcutRegisterDirective, "[shortcutRegister]", never, { "shortcutRegister": { "alias": "shortcutRegister"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ShortcutHandlerDirective extends BaseDirective {
    shortcutHandler: ShortCuts | null;
    shortCutCommand: EventEmitter<ShortCutData>;
    onKeyEnter: (_: KeyboardEvent) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortcutHandlerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShortcutHandlerDirective, "[shortcutHandler]", never, { "shortcutHandler": { "alias": "shortcutHandler"; "required": false; }; }, { "shortCutCommand": "shortCutCommand"; }, never, never, false, never>;
}

declare class BarsaReadonlyDirective extends BaseDirective implements AfterViewInit {
    barsaReadonly: FieldSetting;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaReadonlyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BarsaReadonlyDirective, "[barsaReadonly]", never, { "barsaReadonly": { "alias": "barsaReadonly"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ResizeObserverDirective implements OnInit, OnDestroy {
    elResized: EventEmitter<DOMRectReadOnly>;
    private el;
    private zone;
    private observer;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeObserverDirective, "[resizeObserver]", never, {}, { "elResized": "elResized"; }, never, never, false, never>;
}

declare class ColumnValueDirective extends BaseDirective implements AfterViewInit {
    columnValue: string;
    ngOnChanges(changes: SimpleChanges): void;
    _setInnerHtml(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnValueDirective, "[columnValue]", never, { "columnValue": { "alias": "columnValue"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ScrollToSelectedDirective extends BaseDirective implements OnChanges {
    scrollToSelected: boolean;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private _scrollIntoView;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToSelectedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollToSelectedDirective, "[scrollToSelected]", never, { "scrollToSelected": { "alias": "scrollToSelected"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ScrollPersistDirective implements AfterViewInit, OnDestroy {
    key: string;
    private observer;
    private el;
    private _inMemoryService;
    ngAfterViewInit(): void;
    onScroll(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollPersistDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollPersistDirective, "[scrollPersist]", never, { "key": { "alias": "scrollPersist"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TooltipDirective implements OnDestroy {
    bnrcTooltip: i0.InputSignal<string>;
    private hostRef;
    private renderer;
    private document;
    private tooltipEl;
    ngOnDestroy(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    private removeTooltip;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[bnrcTooltip]", never, { "bnrcTooltip": { "alias": "bnrcTooltip"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class SimplebarDirective extends BaseDirective {
    ngAfterViewInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimplebarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SimplebarDirective, "[simplebar]", never, {}, {}, never, never, false, never>;
}

declare class LeafletLongPressDirective implements OnInit, OnDestroy, OnChanges {
    map: any;
    longPressDuration: number;
    longPress: EventEmitter<any>;
    private sub;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    _initMap(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletLongPressDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LeafletLongPressDirective, "[leafletLongPress]", never, { "map": { "alias": "leafletLongPress"; "required": false; }; "longPressDuration": { "alias": "longPressDuration"; "required": false; }; }, { "longPress": "longPress"; }, never, never, false, never>;
}

declare class PortalDynamicPageResolver {
    private portalService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    resolve(route: ActivatedRouteSnapshot): Observable<PageDataModel | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalDynamicPageResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalDynamicPageResolver>;
}

declare class PortalFormPageResolver {
    constructor();
    resolve(route: ActivatedRouteSnapshot): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalFormPageResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalFormPageResolver>;
}

declare class PortalPageResolver {
    private portalService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    resolve(route: ActivatedRouteSnapshot): Observable<PageDataModel | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalPageResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalPageResolver>;
}

declare class PortalReportPageResolver {
    private portalService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    resolve(route: ActivatedRouteSnapshot): Observable<PageDataModel | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalReportPageResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalReportPageResolver>;
}

declare class TileGroupBreadcrumResolver {
    private _localStorage;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    resolve(_route: ActivatedRouteSnapshot): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileGroupBreadcrumResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TileGroupBreadcrumResolver>;
}

declare class LoginSettingsResolver {
    constructor();
    resolve(_route: ActivatedRouteSnapshot): Promise<ILoginSettings>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginSettingsResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoginSettingsResolver>;
}
interface ILoginSettings {
    Title: string;
    Subtitle: string;
    Section1Title: string;
    Section1Description: string;
    HideGovSso: boolean;
    LogoOnTop: boolean;
    UserPassEnable: boolean;
    GovSSOHref: string;
    DefaultState: string;
    OtpProvider: string;
    BackgroundPicture?: FilePictureInfoModel;
    HeightOfBackground?: number;
    HeightOfLogo?: number;
    LoginType: number;
    Logo: FilePictureInfoModel | null;
    WidthOfBackground?: number;
    WidthOfLogo?: number;
}

interface FormNewSetting {
    MetaTypeDef: MetaobjectDataModel;
    MetaView: MetaobjectDataModel;
    DisableGenerateId: boolean;
    ResolveMoId?: string;
}
declare class FormNewComponent extends BaseComponent implements OnInit {
    settings: FormNewSetting;
    newId: string;
    params: {
        moId: string;
        typeDefId: string;
        viewId: string;
    };
    private _location;
    ngOnInit(): void;
    onFormClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormNewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormNewComponent, "bnrc-form-new", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ReportContainerComponent extends BaseComponent implements OnInit {
    settings: ContainerReportSetting;
    loading$: Observable<boolean>;
    private _activatedRoute;
    private portalService;
    private injector;
    private vcr;
    private _loadingSource;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportContainerComponent, "bnrc-report-container", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FieldUiComponent extends BaseComponent implements OnInit, OnChanges {
    isSearchPanel: boolean;
    customField: any;
    componentUi: EjrayOlgo;
    layoutInfo: LayoutSetting;
    inlineEdit: boolean;
    focusControl: boolean;
    cellEdit: boolean;
    formHeight: number;
    width: string;
    vcr: ViewContainerRef;
    uniquId: any;
    private _formPanelService;
    private _portalService;
    private _injector;
    private _cdr;
    private _component;
    private _customFieldChange$;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    ngOnInit(): Promise<void>;
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    ngOnDestroy(): void;
    inserFieldToContainer(): Promise<void>;
    private _setContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldUiComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldUiComponent, "bnrc-field-ui", never, { "isSearchPanel": { "alias": "isSearchPanel"; "required": false; }; "customField": { "alias": "customField"; "required": false; }; "componentUi": { "alias": "componentUi"; "required": false; }; "layoutInfo": { "alias": "layoutInfo"; "required": false; }; "inlineEdit": { "alias": "inlineEdit"; "required": false; }; "focusControl": { "alias": "focusControl"; "required": false; }; "cellEdit": { "alias": "cellEdit"; "required": false; }; "formHeight": { "alias": "formHeight"; "required": false; }; }, {}, never, never, false, never>;
}

declare function formRoutes(authGuard?: boolean): any;

declare abstract class BaseModule {
    protected dcm: DynamicComponentService;
    protected componentFactoryResolver: ComponentFactoryResolver;
    protected moduleName: string;
    private selectorToFactoryMap;
    private isInitialize;
    protected abstract dynamicComponents: Type<any>[];
    constructor(dcm: DynamicComponentService, componentFactoryResolver: ComponentFactoryResolver, moduleName: string);
    getComponentFactory(componentName: string): ComponentFactory<any>;
    private populateRegistry;
}

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

declare class BarsaSapUiFormPageModule extends BaseModule {
    protected dcm: DynamicComponentService;
    protected cfr: ComponentFactoryResolver;
    protected dynamicComponents: never[];
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaSapUiFormPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BarsaSapUiFormPageModule, never, [typeof i1$1.CommonModule, typeof i137.FormsModule, typeof BarsaSapUiFormPageRoutingModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BarsaSapUiFormPageModule>;
}

interface IBaseController {
    init: () => void;
}
declare abstract class BaseController<T> implements IBaseController {
    view: T;
    /**
     *
     */
    setView(view: T): void;
    abstract init(): void;
}

interface IViewBase {
    controller: IBaseController;
    errorMessage: WritableSignal<string>;
    errorCode: WritableSignal<number>;
    ngOnInit: () => void;
    showError: (message: string, code: number) => void;
}
declare class ViewBase<T extends IBaseController> implements IViewBase, OnInit {
    controller: T;
    errorMessage: WritableSignal<string>;
    errorCode: WritableSignal<number>;
    ngOnInit(): void;
    showError(message: string, code: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewBase<any>, never, never, {}, {}, never, never, false, never>;
}

interface IApiResult {
    data: any;
    error?: any;
    succeed: boolean;
}

declare class ModalRootComponent extends BaseComponent implements OnInit, AfterViewInit {
    componentType: Type<any>;
    componentInstance: ComponentRef<any>;
    private factoryResolver;
    private injector;
    private _appRef;
    ngOnInit(): void;
    close(): void;
    insertComponent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalRootComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalRootComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class ButtonLoadingComponent {
    valid: boolean;
    loading: boolean;
    text: string;
    transparent: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonLoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonLoadingComponent, "bnrc-button-loading", never, { "valid": { "alias": "valid"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "text": { "alias": "text"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; }, {}, never, never, false, never>;
}

declare class UnlimitSessionComponent extends BaseComponent {
    private _portalService;
    private _storageService;
    private _Key;
    ngOnInit(): void;
    private _setStandaloneApp;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnlimitSessionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UnlimitSessionComponent, "bnrc-unlimit-session", never, {}, {}, never, never, false, never>;
}

declare const APP_VERSION: InjectionToken<string>;
declare const DIALOG_SERVICE: InjectionToken<string>;
declare const FORM_DIALOG_COMPONENT: InjectionToken<string>;
declare const NOTIFICATAION_POPUP_SERVER: InjectionToken<NotificationPopupService>;
declare const TOAST_SERVICE: InjectionToken<ToastService>;
declare const NOTIFICATION_WEBWORKER_FACTORY: InjectionToken<() => Worker>;

declare abstract class BaseUlvSettingComponent extends BaseComponent implements OnInit {
    mobile: any;
    context: any;
    originalSetting: any;
    allColumns: ReportViewColumn[];
    sortSettings: SortSetting[];
    ngOnInit(): void;
    onCancelSettings(): void;
    onOkClick(): void;
    onClose(): void;
    protected getSettings(): GridSetting;
    protected abstract close(setting: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseUlvSettingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseUlvSettingComponent, "bnrc-base-ulv-setting", never, {}, {}, never, never, false, never>;
}

declare class CustomRouteReuseStategy implements RouteReuseStrategy {
    handlers: {
        [key: string]: DetachedRouteHandle;
    };
    shouldDetach(route: ActivatedRouteSnapshot): boolean;
    store(route: ActivatedRouteSnapshot, handle: Record<string, unknown>): void;
    shouldAttach(route: ActivatedRouteSnapshot): boolean;
    retrieve(route: ActivatedRouteSnapshot): Record<string, unknown> | null;
    shouldReuseRoute(future: ActivatedRouteSnapshot): boolean;
}

declare class AuthGuard implements CanActivate {
    protected _portalService: PortalService;
    private router;
    canActivate(activatedRouteSnapshot: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
}

declare class RedirectHomeGuard implements CanActivate {
    protected _portalService: PortalService;
    private router;
    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
    private _handle;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedirectHomeGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RedirectHomeGuard>;
}

declare class RootPageComponent extends BaseComponent {
    _pageContent: boolean;
    protected viewContainerRef: ViewContainerRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<RootPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RootPageComponent, "bnrc-root-page", never, {}, {}, never, never, false, never>;
}

declare class ResizableComponent {
    disableResize: boolean;
    rtl: boolean;
    widthChange: EventEmitter<void>;
    widthChanging: EventEmitter<number>;
    private _el;
    private _renderer2;
    onResize(width: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "th[resizable]", never, { "disableResize": { "alias": "disableResize"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; }, { "widthChange": "widthChange"; "widthChanging": "widthChanging"; }, never, ["*"], false, never>;
}

declare class ResizableDirective {
    rtl: boolean;
    resizableComplete: EventEmitter<void>;
    readonly resizable: Observable<number>;
    private readonly documentRef;
    private readonly elementRef;
    /**
     *
     */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDirective, "[resizable]", never, { "rtl": { "alias": "rtl"; "required": false; }; }, { "resizableComplete": "resizableComplete"; "resizable": "resizable"; }, never, never, false, never>;
}

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

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

declare class BarsaNovinRayCoreModule extends BaseModule {
    protected dcm: DynamicComponentService;
    protected componentFactoryResolver: ComponentFactoryResolver;
    protected dynamicComponents: (typeof EmptyPageWithRouterAndRouterOutletComponent | typeof ButtonLoadingComponent)[];
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor();
    static forRoot(): ModuleWithProviders<BarsaNovinRayCoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarsaNovinRayCoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BarsaNovinRayCoreModule, [typeof FormComponent, typeof FieldUiComponent, typeof NotFoundComponent, typeof RootPageComponent, typeof RootPortalComponent, typeof ReportContainerComponent, typeof FormNewComponent, typeof ModalRootComponent, typeof PortalPageComponent, typeof PortalPageSidebarComponent, typeof RedirectReportNavigatorCommandComponent, typeof EmptyPageWithRouterAndRouterOutletComponent, typeof DynamicItemComponent, typeof DynamicFormComponent, typeof BaseDynamicComponent, typeof DynamicFormToolbaritemComponent, typeof DynamicLayoutComponent, typeof EmptyPageComponent, typeof MasterDetailsPageComponent, typeof FormPageComponent, typeof FormFieldReportPageComponent, typeof ButtonLoadingComponent, typeof UnlimitSessionComponent, typeof DynamicTileGroupComponent, typeof NumeralPipe, typeof CanUploadFilePipe, typeof RemoveNewlinePipe, typeof ConvertToStylePipe, typeof FilterPipe, typeof FilterTabPipe, typeof FilterStringPipe, typeof FioriIconPipe, typeof SortPipe, typeof GroupByPipe, typeof MultipleGroupByPipe, typeof MoValuePipe, typeof MoReportValuePipe, typeof HeaderFacetValuePipe, typeof PictureFieldSourcePipe, typeof TlbButtonsPipe, typeof SeperatorFixPipe, typeof MoReportValueConcatPipe, typeof ContextMenuPipe, typeof BbbTranslatePipe, typeof BarsaIconDictPipe, typeof FileInfoCountPipe, typeof ControlUiPipe, typeof VisibleValuePipe, typeof FilterToolbarControlPipe, typeof ListCountPipe, typeof TotalSummaryPipe, typeof MergeFieldsToColumnsPipe, typeof FindColumnByDbNamePipe, typeof FilterColumnsByDetailsPipe, typeof MoInfoUlvMoListPipe, typeof MoInfoUlvPagingPipe, typeof ReversePipe, typeof ColumnCustomUiPipe, typeof SanitizeTextPipe, typeof ColumnCustomComponentPipe, typeof ColumnIconPipe, typeof ColumnValuePipe, typeof RowNumberPipe, typeof ComboRowImagePipe, typeof IsExpandedNodePipe, typeof ThImageOrIconePipe, typeof FindPreviewColumnPipe, typeof ReplacePipe, typeof FilterWorkflowInMobilePipe, typeof HideColumnsInmobilePipe, typeof StringToNumberPipe, typeof ColumnValueOfParametersPipe, typeof HideAcceptCancelButtonsPipe, typeof FilterInlineActionListPipe, typeof IsImagePipe, typeof ToolbarSettingsPipe, typeof CardMediaSizePipe, typeof LabelStarTrimPipe, typeof SplitPipe, typeof DynamicDarkColorPipe, typeof ChunkArrayPipe, typeof MapToChatMessagePipe, typeof PlaceHolderDirective, typeof NumbersOnlyInputDirective, typeof RenderUlvViewerDirective, typeof RenderUlvPaginDirective, typeof AnchorScrollDirective, typeof ItemsRendererDirective, typeof UlvCommandDirective, typeof DynamicCommandDirective, typeof WorfkflowwChoiceCommandDirective, typeof ImageLazyDirective, typeof UntilInViewDirective, typeof IntersectionObserverDirective, typeof EllipsifyDirective, typeof TableResizerDirective, typeof ColumnResizerDirective, typeof AttrRtlDirective, typeof CopyDirective, typeof EllapsisTextDirective, typeof FillEmptySpaceDirective, typeof FormCloseDirective, typeof MobileDirective, typeof BodyClickDirective, typeof CountDownDirective, typeof RouteFormChangeDirective, typeof DynamicStyleDirective, typeof NowraptextDirective, typeof LabelmandatoryDirective, typeof AbsoluteDivBodyDirective, typeof LoadExternalFilesDirective, typeof StopPropagationDirective, typeof PreventDefaultDirective, typeof RenderUlvDirective, typeof PrintFilesDirective, typeof SaveImageDirective, typeof WebOtpDirective, typeof SplideSliderDirective, typeof DynamicRootVariableDirective, typeof HorizontalResponsiveDirective, typeof MeasureFormTitleWidthDirective, typeof OverflowTextDirective, typeof ShortcutRegisterDirective, typeof ShortcutHandlerDirective, typeof BarsaReadonlyDirective, typeof ResizeObserverDirective, typeof ColumnValueDirective, typeof ScrollToSelectedDirective, typeof ScrollPersistDirective, typeof TooltipDirective, typeof SimplebarDirective, typeof LeafletLongPressDirective], [typeof i1$1.CommonModule, typeof BarsaNovinRayCoreRoutingModule, typeof BarsaSapUiFormPageModule, typeof ResizableModule, typeof i137.FormsModule, typeof i137.ReactiveFormsModule], [typeof FormComponent, typeof FieldUiComponent, typeof NotFoundComponent, typeof RootPageComponent, typeof RootPortalComponent, typeof ReportContainerComponent, typeof FormNewComponent, typeof ModalRootComponent, typeof PortalPageComponent, typeof PortalPageSidebarComponent, typeof RedirectReportNavigatorCommandComponent, typeof EmptyPageWithRouterAndRouterOutletComponent, typeof DynamicItemComponent, typeof DynamicFormComponent, typeof BaseDynamicComponent, typeof DynamicFormToolbaritemComponent, typeof DynamicLayoutComponent, typeof EmptyPageComponent, typeof MasterDetailsPageComponent, typeof FormPageComponent, typeof FormFieldReportPageComponent, typeof ButtonLoadingComponent, typeof UnlimitSessionComponent, typeof DynamicTileGroupComponent, typeof NumeralPipe, typeof CanUploadFilePipe, typeof RemoveNewlinePipe, typeof ConvertToStylePipe, typeof FilterPipe, typeof FilterTabPipe, typeof FilterStringPipe, typeof FioriIconPipe, typeof SortPipe, typeof GroupByPipe, typeof MultipleGroupByPipe, typeof MoValuePipe, typeof MoReportValuePipe, typeof HeaderFacetValuePipe, typeof PictureFieldSourcePipe, typeof TlbButtonsPipe, typeof SeperatorFixPipe, typeof MoReportValueConcatPipe, typeof ContextMenuPipe, typeof BbbTranslatePipe, typeof BarsaIconDictPipe, typeof FileInfoCountPipe, typeof ControlUiPipe, typeof VisibleValuePipe, typeof FilterToolbarControlPipe, typeof ListCountPipe, typeof TotalSummaryPipe, typeof MergeFieldsToColumnsPipe, typeof FindColumnByDbNamePipe, typeof FilterColumnsByDetailsPipe, typeof MoInfoUlvMoListPipe, typeof MoInfoUlvPagingPipe, typeof ReversePipe, typeof ColumnCustomUiPipe, typeof SanitizeTextPipe, typeof ColumnCustomComponentPipe, typeof ColumnIconPipe, typeof ColumnValuePipe, typeof RowNumberPipe, typeof ComboRowImagePipe, typeof IsExpandedNodePipe, typeof ThImageOrIconePipe, typeof FindPreviewColumnPipe, typeof ReplacePipe, typeof FilterWorkflowInMobilePipe, typeof HideColumnsInmobilePipe, typeof StringToNumberPipe, typeof ColumnValueOfParametersPipe, typeof HideAcceptCancelButtonsPipe, typeof FilterInlineActionListPipe, typeof IsImagePipe, typeof ToolbarSettingsPipe, typeof CardMediaSizePipe, typeof LabelStarTrimPipe, typeof SplitPipe, typeof DynamicDarkColorPipe, typeof ChunkArrayPipe, typeof MapToChatMessagePipe, typeof PlaceHolderDirective, typeof NumbersOnlyInputDirective, typeof RenderUlvViewerDirective, typeof RenderUlvPaginDirective, typeof AnchorScrollDirective, typeof ItemsRendererDirective, typeof UlvCommandDirective, typeof DynamicCommandDirective, typeof WorfkflowwChoiceCommandDirective, typeof ImageLazyDirective, typeof UntilInViewDirective, typeof IntersectionObserverDirective, typeof EllipsifyDirective, typeof TableResizerDirective, typeof ColumnResizerDirective, typeof AttrRtlDirective, typeof CopyDirective, typeof EllapsisTextDirective, typeof FillEmptySpaceDirective, typeof FormCloseDirective, typeof MobileDirective, typeof BodyClickDirective, typeof CountDownDirective, typeof RouteFormChangeDirective, typeof DynamicStyleDirective, typeof NowraptextDirective, typeof LabelmandatoryDirective, typeof AbsoluteDivBodyDirective, typeof LoadExternalFilesDirective, typeof StopPropagationDirective, typeof PreventDefaultDirective, typeof RenderUlvDirective, typeof PrintFilesDirective, typeof SaveImageDirective, typeof WebOtpDirective, typeof SplideSliderDirective, typeof DynamicRootVariableDirective, typeof HorizontalResponsiveDirective, typeof MeasureFormTitleWidthDirective, typeof OverflowTextDirective, typeof ShortcutRegisterDirective, typeof ShortcutHandlerDirective, typeof BarsaReadonlyDirective, typeof ResizeObserverDirective, typeof ColumnValueDirective, typeof ScrollToSelectedDirective, typeof ScrollPersistDirective, typeof TooltipDirective, typeof SimplebarDirective, typeof LeafletLongPressDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BarsaNovinRayCoreModule>;
}

export { APP_VERSION, AbsoluteDivBodyDirective, AffixRespondEvents, AllFilesMimeType, AnchorScrollDirective, ApiService, ApplicationBaseComponent, ApplicationCtrlrService, AttrRtlDirective, AudioMimeType, AudioRecordingService, AuthGuard, BBB, BarsaApi, BarsaDialogService, BarsaIconDictPipe, BarsaNovinRayCoreModule, BarsaReadonlyDirective, BarsaSapUiFormPageModule, BarsaStorageService, BaseColumnPropsComponent, BaseComponent, BaseController, BaseDirective, BaseDynamicComponent, BaseFormToolbaritemPropsComponent, BaseItemContentPropsComponent, BaseModule, BaseReportModel, BaseUlvSettingComponent, BaseViewContentPropsComponent, BaseViewItemPropsComponent, BaseViewPropsComponent, BbbTranslatePipe, BodyClickDirective, BoolControlInfoModel, BreadcrumbService, ButtonLoadingComponent, Bw, CalculateControlInfoModel, CalendarMetaobjectDataModel, CanUploadFilePipe, CardMediaSizePipe, ChangeLayoutInfoCustomUi, ChunkArrayPipe, CodeEditorControlInfoModel, ColSetting, ColumnCustomComponentPipe, ColumnCustomUiPipe, ColumnIconPipe, ColumnResizerDirective, ColumnService, ColumnValueDirective, ColumnValueOfParametersPipe, ColumnValuePipe, ComboRowImagePipe, CommandControlInfoModel, Common, ContainerComponent, ContainerService, ContextMenuPipe, ControlUiPipe, ConvertToStylePipe, CopyDirective, CountDownDirective, CustomCommand, CustomInjector, CustomRouteReuseStategy, DIALOG_SERVICE, DateHijriService, DateMiladiService, DateRanges, DateService, DateShamsiService, DateTimeControlInfoModel, DeviceWidth, DialogParams, DynamicCommandDirective, DynamicComponentService, DynamicDarkColorPipe, DynamicFormComponent, DynamicFormToolbaritemComponent, DynamicItemComponent, DynamicLayoutComponent, DynamicRootVariableDirective, DynamicStyleDirective, DynamicTileGroupComponent, EllapsisTextDirective, EllipsifyDirective, EmptyPageComponent, EmptyPageWithRouterAndRouterOutletComponent, EnumControlInfoModel, ExecuteDynamicCommand, ExecuteWorkflowChoiceDef, Ext, FORM_DIALOG_COMPONENT, FieldBaseComponent, FieldDirective, FieldInfoTypeEnum, FieldUiComponent, FileControlInfoModel, FileInfoCountPipe, FilePictureInfoModel, FilesValidationHelper, FillAllLayoutControls, FillEmptySpaceDirective, FilterColumnsByDetailsPipe, FilterInlineActionListPipe, FilterPipe, FilterStringPipe, FilterTabPipe, FilterToolbarControlPipe, FilterWorkflowInMobilePipe, FindColumnByDbNamePipe, FindGroup, FindLayoutSettingFromLayout94, FindPreviewColumnPipe, FindToolbarItem, FioriIconPipe, FormBaseComponent, FormCloseDirective, FormComponent, FormFieldReportPageComponent, FormNewComponent, FormPageBaseComponent, FormPageComponent, FormPanelService, FormPropsBaseComponent, FormService, FormToolbarBaseComponent, GanttChartHelper, GaugeControlInfoModel, GeneralControlInfoModel, GetAllColumnsSorted, GetAllHorizontalFromLayout94, GetDefaultMoObjectInfo, GetImgTags, GetVisibleValue, GridSetting, GroupBy, GroupByPipe, GroupByService, HeaderFacetValuePipe, HideAcceptCancelButtonsPipe, HideColumnsInmobilePipe, HistoryControlInfoModel, HorizontalLayoutService, HorizontalResponsiveDirective, IconControlInfoModel, ImageLazyDirective, ImageMimeType, ImagetoPrint, InMemoryStorageService, IndexedDbService, InputNumber, IntersectionObserverDirective, IntersectionStatus, IsDarkMode, IsExpandedNodePipe, IsImagePipe, ItemsRendererDirective, LabelStarTrimPipe, LabelmandatoryDirective, LayoutItemBaseComponent, LayoutMainContentService, LayoutPanelBaseComponent, LayoutService, LeafletLongPressDirective, LinearListControlInfoModel, LinearListHelper, ListCountPipe, ListRelationModel, LoadExternalFilesDirective, LocalStorageService, LogService, LoginAction, LoginForm, LoginFormData, LoginFormUi, LoginSettingsResolver, MapToChatMessagePipe, MasterDetailsPageComponent, MeasureFormTitleWidthDirective, MergeFieldsToColumnsPipe, MetaobjectDataModel, MetaobjectRelationModel, MoForReportModel, MoForReportModelBase, MoInfoUlvMoListPipe, MoInfoUlvPagingPipe, MoReportValueConcatPipe, MoReportValuePipe, MoValuePipe, MobileDirective, ModalRootComponent, MultipleGroupByPipe, NOTIFICATAION_POPUP_SERVER, NOTIFICATION_WEBWORKER_FACTORY, NetworkStatusService, NotFoundComponent, NotificationService, NowraptextDirective, NumberBaseComponent, NumberControlInfoModel, NumbersOnlyInputDirective, NumeralPipe, Offline, OverflowTextDirective, PageBaseComponent, PageWithFormHandlerBaseComponent, PdfMimeType, PictureFieldSourcePipe, PictureFileControlInfoModel, PlaceHolderDirective, PortalDynamicPageResolver, PortalFormPageResolver, PortalPageComponent, PortalPageResolver, PortalPageSidebarComponent, PortalReportPageResolver, PortalService, PreventDefaulEvent, PreventDefaultDirective, PrintFilesDirective, PrintImage, PromptUpdateService, RabetehAkseTakiListiControlInfoModel, RedirectHomeGuard, RedirectReportNavigatorCommandComponent, RelatedReportControlInfoModel, RelationListControlInfoModel, RemoveNewlinePipe, RenderUlvDirective, RenderUlvPaginDirective, RenderUlvViewerDirective, ReplacePipe, ReportBaseComponent, ReportBaseInfo, ReportCalendarModel, ReportContainerComponent, ReportExtraInfo, ReportField, ReportFormModel, ReportItemBaseComponent, ReportListModel, ReportModel, ReportTreeModel, ReportViewBaseComponent, ReportViewColumn, ResizableComponent, ResizableDirective, ResizableModule, ResizeObserverDirective, ReversePipe, RichStringControlInfoModel, RootPageComponent, RootPortalComponent, RouteFormChangeDirective, RoutingService, RowDataOption, RowNumberPipe, SanitizeTextPipe, SaveImageDirective, SaveImageToFile, SaveScrollPositionService, ScrollPersistDirective, ScrollToSelectedDirective, SelectionMode, SeperatorFixPipe, ServiceWorkerCommuncationService, ServiceWorkerNotificationService, ShellbarHeightService, ShortcutHandlerDirective, ShortcutRegisterDirective, SimplebarDirective, SingleRelationControlInfoModel, SortDirection, SortPipe, SortSetting, SplideSliderDirective, SplitPipe, StopPropagationDirective, StringControlInfoModel, StringToNumberPipe, SubformControlInfoModel, SystemBaseComponent, TOAST_SERVICE, TableHeaderWidthMode, TableResizerDirective, TabpageService, ThImageOrIconePipe, TileGroupBreadcrumResolver, TilePropsComponent, TlbButtonsPipe, ToolbarSettingsPipe, TooltipDirective, TotalSummaryPipe, Ui, UiService, Ul, UlvCommandDirective, UlvMainCtrl, UlvMainService, UnlimitSessionComponent, UntilInViewDirective, UploadService, Util, VideoMimeType, VideoRecordingService, ViewBase, VisibleValuePipe, WebOtpDirective, WordMimeType, WorfkflowwChoiceCommandDirective, addCssVariableToRoot, availablePrefixes, calcContextMenuWidth, calculateColumnContent, calculateColumnWidth, calculateColumnWidthFitToContainer, calculateFreeColumnSize, calculateMoDataListContentWidthByColumnName, cancelRequestAnimationFrame, createFormPanelMetaConditions, createGridEditorFormPanel, easeInOutCubic, elementInViewport2, enumValueToStringSize, executeUlvCommandHandler, flattenTree, forbiddenValidator, formRoutes, formatBytes, fromEntries, fromIntersectionObserver, genrateInlineMoId, getAllItemsPerChildren, getColumnValueOfMoDataList, getComponentDefined, getControlList, getControlSizeMode, getDateService, getDeviceIsDesktop, getDeviceIsMobile, getDeviceIsPhone, getDeviceIsTablet, getFieldValue, getFocusableTagNames, getFormSettings, getGridSettings, getHeaderValue, getIcon, getImagePath, getLabelWidth, getLayout94ObjectInfo, getLayoutControl, getNewMoGridEditor, getParentHeight, getRequestAnimationFrame, getResetGridSettings, getTargetRect, getUniqueId, getValidExtension, isFF, isFirefox, isFunction, isImage, isInLocalMode, isSafari, isTargetWindow, measureText, measureText2, measureTextBy, mobile_regex, nullOrUndefinedString, number_only, requestAnimationFramePolyfill, setColumnWidthByMaxMoContentWidth, setOneDepthLevel, setTableThWidth, shallowEqual, stopPropagation, throwIfAlreadyLoaded, toNumber, validateAllFormFields };
export type { AbbrevationDeviceSize, AppMenu, AppTile, AppTileGroup, ApplicationSetting, BreadCrumbInfo, BruleActionMessage, CalendarFields, CalendarView, CardMediaSize, CartableTemplateKey, ChoiceDef, ClassNamesModel, CollectionGroup, CollectionPage, CollectionSort, CollectionState, ColumnInfoType, ColumnResizedArgs, ColumnSummaryType, Command, CommandGroup, CommonObservable, ComponentDataModel, ComponentSettingsDataModel, ContainerReportSetting, ControlInfoTypes, CssBackground, CultureTypes, CustomApplicationMenuBodyUi, CustomApplicationUi, CustomNavGroupUi, CustomNavPageUi, CustomRibbon, CustomSystemContainerUi, CustomSystemNavUi, CustomSystemUi, DateInfo, DefaultCommandsAccess, DeviceSize, DownloadFileInfo, DownloadFileInfoResult, EasyingFn, EjrayOlgo, ExNotificationPayload, ExtraModel, FieldSetting, FieldSettings, FileAttachmentInfo, FormComponentParams, FormSetting, FormView, FormViewSetting, FormVisibilityStatus, GridView, Group, GroupByItem, GroupVisibility, IApiResult, IBaseController, IDebug, IHeaderLayout, ISystem, ISystemData, IUploadingState, IViewBase, IndexableObject, InfoBarType, LayoutSetting, LibraryDepenecy, LoginResult, MenuItem, ModuleDataModel, ModuleListReportModel, ModuleWithDynamicComponents, Modules, NavGroupItem, NavGroupItemData, Navigator, NavigatorFolder, NavigatorFolderItem, NavigatorItem, NavigatorRoot, NavigatorRootItem, NgStyleInterface, NotificationAction, NotificationItem, NotificationPayload, NotificationPopupService, NotifyOptions, NumberInput, NzSafeAny, NzScrollToOptions, PageDataModel, PageListReportModel, PagingSetting, PlaceHolderDataModel, PortalDataModel, RelationItemType, RelationListTypes, ReportItemSetting, ReportModelTypes, ReportSetting, SearchInput, SearchPanelSettings, ShareButtonsChoiceDef, ShellbarSetting, ShortCutData, ShortCuts, SimpleRect, SortOrder, SystemSetting, TableState, TreeNodeObj, TreeView, TypeUlvDataCtrlr, TypeUlvMainCtrlr, UiReportViewBase, UiReportViewBaseSetting, UiResponsiveSettings, UlvParamType, User, ViewTypes, WorkflowExecuteChoiceStatus, WorkflowItem, columnsResizedEventArgs };