import * as i0 from '@angular/core';
import { OnInit, EventEmitter, OnChanges, SimpleChanges, InjectionToken, ComponentRef, OnDestroy, ElementRef, AfterContentChecked, ViewContainerRef, ChangeDetectorRef, AfterViewInit, QueryList } from '@angular/core';
import { FormControl, AbstractControl, FormArray, ValidatorFn } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import { MenuItem, MessageService } from 'primeng/api';
import { Select } from 'primeng/select';
import * as _angular_platform_browser from '@angular/platform-browser';
import { DomSanitizer } from '@angular/platform-browser';
import { MultiSelect } from 'primeng/multiselect';
import { TranslateService } from '@ngx-translate/core';
import { DatePickerTypeView } from 'primeng/datepicker';
import { Router, ActivatedRoute } from '@angular/router';

declare class NgBaseLib {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgBaseLib, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgBaseLib, "lib-ng-base-lib", never, {}, {}, never, never, true, never>;
}

declare abstract class BaseFieldControlComponent {
    private _errorMessageList;
    id?: string;
    label: string;
    disabled: boolean;
    fieldControl: FormControl<any>;
    required: boolean;
    placeholder: string;
    visibility: string;
    set errorMessageList(val: any);
    get errorMessageList(): any;
    labelOneLine: boolean;
    name: string;
    iconLabelTooltip: string | {
        key: string;
        param: object;
    };
    styleClass: string;
    errorMessage: string;
    checkRequiredField(): boolean;
    checkInvalidField(): boolean;
    checkDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFieldControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFieldControlComponent, "ng-component", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fieldControl": { "alias": "fieldControl"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "visibility": { "alias": "visibility"; "required": false; }; "errorMessageList": { "alias": "errorMessageList"; "required": false; }; "labelOneLine": { "alias": "labelOneLine"; "required": false; }; "name": { "alias": "name"; "required": false; }; "iconLabelTooltip": { "alias": "iconLabelTooltip"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BaseButtonComponent extends BaseFieldControlComponent implements OnInit {
    outlined: boolean;
    color: 'normal' | 'red' | 'yellow' | 'green';
    iconUrl: string;
    rightIcon: boolean;
    iconName: string;
    type: 'normal' | 'split';
    buttonType: 'button' | 'submit';
    isTextStyle: boolean;
    rounded: boolean;
    splitButtonItems: {
        label: string;
        icon?: string;
        command?: () => void;
    }[];
    splitOneClick: boolean;
    onClick: EventEmitter<any>;
    actionType?: string | string[];
    createdBy?: string;
    moduleCode?: any;
    buttonClass: string;
    loading: boolean;
    raised: boolean;
    isSpinning: boolean;
    severity: 'primary' | 'secondary';
    constructor();
    actionPermission: {
        moduleCode: string | string[];
        actionType: string | string[];
    };
    ngOnInit(): void;
    click($event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseButtonComponent, "app-base-button", never, { "outlined": { "alias": "outlined"; "required": false; }; "color": { "alias": "color"; "required": false; }; "iconUrl": { "alias": "iconUrl"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "type": { "alias": "type"; "required": false; }; "buttonType": { "alias": "buttonType"; "required": false; }; "isTextStyle": { "alias": "isTextStyle"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "splitButtonItems": { "alias": "splitButtonItems"; "required": false; }; "splitOneClick": { "alias": "splitOneClick"; "required": false; }; "actionType": { "alias": "actionType"; "required": false; }; "createdBy": { "alias": "createdBy"; "required": false; }; "moduleCode": { "alias": "moduleCode"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "raised": { "alias": "raised"; "required": false; }; "isSpinning": { "alias": "isSpinning"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
}

declare class BaseLabelComponent implements OnInit, OnChanges {
    mode: 'normal' | 'error';
    label: string | {
        key: string;
        param: object;
    };
    labelOneLine: boolean;
    showOptionalText: boolean;
    required: boolean;
    optionalText: boolean;
    labelStyle: string;
    iconLabelTooltip: string | {
        key: string;
        param: object;
    };
    labelKey: string;
    param: object;
    iconLabelTooltipKey: string;
    iconLabelTooltipParam: object;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseLabelComponent, "app-base-label", never, { "mode": { "alias": "mode"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelOneLine": { "alias": "labelOneLine"; "required": false; }; "showOptionalText": { "alias": "showOptionalText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "optionalText": { "alias": "optionalText"; "required": false; }; "labelStyle": { "alias": "labelStyle"; "required": false; }; "iconLabelTooltip": { "alias": "iconLabelTooltip"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BasedDto {
    tenantId?: string;
    createdDate?: Date;
    createdBy?: string;
    modifiedDate?: Date;
    modifiedBy?: string;
    statusId?: number;
}
interface BaseFormConfig {
    id?: string;
    type: CONTROL_TYPE;
    label?: string | {
        key: string;
        param?: object;
    } | string[];
    name?: string;
    placeholder?: string;
    fieldControl?: FormControl | AbstractControl | null;
    errorMessageList?: ErrorMessageList;
    layoutDefine: {
        row: number;
        column: number;
        colSpan?: number;
    };
    required?: boolean;
    labelOneLine?: boolean;
    cssContainer?: string;
    disabled?: boolean;
    disabledBy?: string;
    disableByCondition?: any;
    visibility?: 'hidden' | 'visible';
    keepValueOnHide?: boolean;
    iconLabelTooltip?: string | {
        key: string;
        param: object;
    };
    dependOnFields?: {
        fields: string[] | EventEmitter<any>[];
        action: (fieldConfig?: FormConfig, comp?: ComponentRef<any>) => void;
        debounce?: number;
    }[];
    styleClass?: string;
}
declare enum CONTROL_TYPE {
    Textbox = "textbox",
    Textarea = "textarea",
    Dropdown = "dropdown",
    Calendar = "calendar",
    Checkbox = "checkbox",
    Radio = "radio",
    Multiselect = "multiselect",
    FormArray = "formarray",
    Label = "label",
    Html = "html",
    InputNumber = "inputNumber",
    ButtonSet = "buttonset",
    InputMask = "inputmask",
    Button = "button",
    Switch = "switch"
}
declare enum CONTROL_TYPE_CODE {
    Textbox = "TXT_S",
    Textarea = "TXT_M",
    Dropdown = "SEL_S",
    Multiselect = "SEL_M",
    Radio = "RAD",
    Checkbox = "CBX_S",
    MultiCheckbox = "CBX_M",
    Number = "NUM",
    Date = "DATE",
    DateTime = "DATETIME",
    Time = "TIME",
    Url = "URL",
    Email = "EML",
    Phone = "PHN",
    User = "USR",
    Country = "COUNTRY",
    State = "STATE",
    City = "CITY",
    Postcode = "POSTCODE",
    Year = "YEAR"
}
declare const NUMBER_INPUT_FORMAT: {
    currency: RegExp;
};
interface ErrorMessageList {
    [key: string]: string | {
        key: string;
        param: object;
    };
}
interface OptionsModel {
    label?: string;
    value: any;
    preIcon?: string | {
        icon?: string;
        style?: IconStyle;
    };
    disabled?: boolean;
    required?: boolean;
}
interface IconStyle {
    [key: string]: string;
}
interface TreeOptionsModel {
    label?: any;
    value: any;
    expandedIcon?: string;
    collapsedIcon?: string;
    icon?: string;
    children?: TreeOptionsModel[];
}
interface BaseInputTextConfig {
    autoFocus?: boolean;
}
interface BaseInputFormConfig extends BaseFormConfig, BaseInputTextConfig {
    type: CONTROL_TYPE.Textbox;
    mode?: 'text' | 'number' | 'password' | 'label-text' | 'email' | 'url' | 'phone' | 'chips';
    prefix?: string;
    suffix?: string;
    onlyNumber?: boolean;
    maxLength?: number;
    min?: number;
    max?: number;
    minFractionDigits?: number;
    maxFractionDigits?: number;
    useGrouping?: boolean;
    content?: string;
    descriptionMessage?: string;
    seperator?: string;
    isValidPassword?: boolean;
    iconLeftStyle?: string;
    iconRightStyle?: string;
}
interface BaseSwitchFormConfig extends BaseFormConfig, BaseInputTextConfig {
    type: CONTROL_TYPE.Switch;
    content?: string;
    descriptionMessage?: string;
    inline?: boolean;
}
interface BaseDatepickerFormConfig extends BaseFormConfig {
    type: CONTROL_TYPE.Calendar;
    mode?: 'range' | 'single' | 'range_2' | 'label-text';
    minDate?: Date;
    maxDate?: Date;
    dateFormat?: string;
    view?: string;
    showTime?: boolean;
    timeOnly?: boolean;
    showSeconds?: boolean;
}
interface BaseTextAreaFormConfig extends BaseFormConfig, BaseInputTextConfig {
    type: CONTROL_TYPE.Textarea;
    labelShowsOptional?: boolean;
    hideLengthLimit?: boolean;
    maxLength?: number;
    autoResize?: boolean;
    instructionText?: string;
    tooltip?: string;
    lineNumber?: number;
}
interface BaseHTMLFormConfig extends BaseFormConfig {
    type: CONTROL_TYPE.Html;
    dynamicHTML: string;
}
type BaseSelectFormConfig = Omit<BaseFormConfig, 'dependOnFields'> & (BaseDataSourceAction | BaseDataSourceWithOptions) & {
    type: CONTROL_TYPE.Radio | CONTROL_TYPE.Checkbox | CONTROL_TYPE.Dropdown | CONTROL_TYPE.Multiselect;
    direction?: 'row' | 'column';
    optionsContainerClass?: string;
    singleSelect?: boolean;
    switchInput?: boolean;
    defaultValue?: any;
    containerClass?: string;
    inputContainerClass?: string;
    labelClass?: string;
    defaultLabel?: string;
    dependOnFields?: {
        fields: (string | EventEmitter<any> | BehaviorSubject<any> | Subject<any> | Observable<any>)[];
        action: (fieldConfig?: BaseDropdownFormConfig, comp?: ComponentRef<any>) => void;
        updateOptions?: boolean;
        debounce?: number;
    }[];
};
type BaseDropdownFormConfig = BaseSelectFormConfig & {
    type: CONTROL_TYPE.Dropdown;
    searchable?: boolean;
    sortOption?: boolean;
    group?: boolean;
    showClear?: boolean;
};
type BaseMultiselectFormConfig = BaseSelectFormConfig & {
    type: CONTROL_TYPE.Multiselect;
    defaultLabel?: string;
    searchable?: boolean;
    sortOption?: boolean;
    group?: boolean;
    showClear?: boolean;
    showChips?: boolean;
};
type BaseCheckBoxFormConfig = BaseSelectFormConfig & {
    type: CONTROL_TYPE.Checkbox;
};
type BaseRadioFormConfig = BaseSelectFormConfig & {
    type: CONTROL_TYPE.Radio;
};
interface BaseDataSourceAction {
    dataSourceAction: (event?: BaseDataSourceActionEvent) => Observable<any>;
    options?: undefined;
    dataSourceDependOn?: string[];
    virtualScroll?: VirtualScrollConfig | true;
}
interface BaseDataSourceActionEvent {
    searchBy?: string;
    pageIndex?: number;
    rowPerPage?: number;
    eventType: 'dependChange' | 'changePageIndex' | 'searchChange' | 'other' | 'initData';
    defaultValue?: any;
}
interface VirtualScrollConfig {
    pageSize?: number;
}
interface BaseDataSourceWithOptions {
    options: OptionsModel[];
}
interface BaseFormArrayConfig extends BaseFormConfig {
    type: CONTROL_TYPE.FormArray;
    fields: FormArrayConfig[];
    fieldControl: FormArray;
    addBtnLabel?: string;
    removeBtnLabel?: string;
}
type FormArrayConfig = FormConfig & {
    fieldControlName: string;
    fieldControl?: undefined;
};
interface BaseLabelFormConfig extends BaseFormConfig {
    type: CONTROL_TYPE.Label;
    mode?: 'normal' | 'error';
    labelOneLine?: boolean;
    required?: boolean;
    labelStyle?: string;
}
interface BaseButtonFormConfig extends BaseFormConfig {
    type: CONTROL_TYPE.Button;
    label?: string;
    outlined?: boolean;
    isTextStyle?: boolean;
    rounded?: boolean;
    loading?: boolean;
    onClickFunc: (e?: any) => void;
    actionPermission?: {
        actionType: string | string[];
        moduleCode?: string;
        createdBy?: string;
    };
    severity?: 'primary' | 'secondary';
}
declare const BASE_UI_TOKEN: InjectionToken<unknown>;
declare const FORM_ARRAY_ITEM_TOKEN: InjectionToken<unknown>;
declare const FORM_ARRAY_TOKEN: InjectionToken<unknown>;
type FormConfig = BaseInputFormConfig | BaseTextAreaFormConfig | BaseDropdownFormConfig | BaseMultiselectFormConfig | BaseCheckBoxFormConfig | BaseRadioFormConfig | BaseDatepickerFormConfig | BaseHTMLFormConfig | BaseLabelFormConfig | BaseFormArrayConfig | BaseButtonFormConfig | BaseSwitchFormConfig;
declare function isBaseButton(config: FormConfig): config is BaseButtonFormConfig;
declare const BASE_FORM_ITEMS_EVENT: {
    OPTIONS_CHANGE: string;
};
interface BaseMenuItem {
    label: string;
    id: string;
    moduleCode?: string | object;
    actionType?: string | string[];
    disable?: boolean;
    command?: any;
}
interface BaseTabMenuItem extends MenuItem {
    moduleCode?: string | object;
    actionType?: string | string[];
}
interface ProtertiesDto {
    propertyId: string;
    uid: string;
    name: string;
    code: string;
    type: string;
    isSystem: boolean;
    isMandatory: boolean;
    isEditable: boolean;
    isVisiable: boolean;
    moduleCode: string;
    order: number;
    statusID: number;
    createdDate: Date;
    createdBy: string;
    modifiedDate: Date;
    modifiedBy: string;
}
interface TableConfig {
    header?: string;
    code: string;
    icon?: string;
}
interface EditorToolbarSetupDto {
    bold?: boolean;
    italic?: boolean;
    underline?: boolean;
    strike?: boolean;
    orderedList?: boolean;
    bulletList?: boolean;
    checklist?: boolean;
    link?: boolean;
    image?: boolean;
    video?: boolean;
    clean?: boolean;
    blockquote?: boolean;
    codeBlock?: boolean;
    align?: boolean;
    size?: boolean;
    font?: boolean;
    color?: boolean;
    backgroundColor?: boolean;
    header?: boolean;
    formula?: boolean;
}
declare class AttachmentDto extends BasedDto {
    uid?: string;
    folderName: string;
    fullPath: string;
    fileName: string;
    fileType: string;
    activityUid: string;
    fileSize: number;
    contactUid: string[];
    companyUid: string[];
    url?: string;
}
declare class MessageModel {
    message: string;
    severity?: 'success' | 'info' | 'warn' | 'error';
    key?: string;
    icon?: string;
    isLoading?: boolean;
    messageData?: any[];
    sticky?: boolean;
}

type DependOnFieldsDataSourceConfig = UpdateOptionsDependOnFieldConfig | NotUpdateOptionsDependOnFieldConfig;
interface UpdateOptionsDependOnFieldConfig {
    fields: string[] | EventEmitter<any>[];
    action: () => Observable<OptionsModel[]>;
    updateOptions: true;
    debounce?: number;
}
interface NotUpdateOptionsDependOnFieldConfig {
    fields: string[] | EventEmitter<any>[];
    action: () => void;
    updateOptions?: false;
}

declare abstract class BaseFieldDataSourceControl extends BaseFieldControlComponent implements OnInit, OnDestroy {
    dependOnFields: DependOnFieldsDataSourceConfig[];
    placeholder: string;
    dataSourceDependOn: string[];
    dataSourceAction: ((event?: BaseDataSourceActionEvent) => Observable<any>) | null;
    sortOption: boolean;
    options: OptionsModel[];
    virtualScroll?: VirtualScrollConfig | true;
    totalRecords: number;
    protected trackingField: Observable<any>[] | EventEmitter<any>[];
    protected currentEvent: BaseDataSourceActionEvent;
    protected lazyLoading: boolean;
    protected destroy$: Subject<unknown>;
    protected optionUpdated: Subject<unknown>;
    parentFieldConfig: FormConfig[];
    ngOnInit(): void;
    protected invokeDependent(updateOptionsDependList: {
        debounce: number;
        action: () => Observable<any>;
    }): void;
    protected getOptions(eventType: BaseDataSourceActionEvent['eventType']): void;
    protected buildEventAction(eventType: BaseDataSourceActionEvent['eventType']): BaseDataSourceActionEvent;
    protected updatedOptions(val: OptionsModel[] | {
        options: OptionsModel[];
        totalRecords: number;
    }, eventType?: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFieldDataSourceControl, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFieldDataSourceControl, "ng-component", never, { "dependOnFields": { "alias": "dependOnFields"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "dataSourceDependOn": { "alias": "dataSourceDependOn"; "required": false; }; "dataSourceAction": { "alias": "dataSourceAction"; "required": false; }; "sortOption": { "alias": "sortOption"; "required": false; }; "options": { "alias": "options"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BaseCheckboxComponent extends BaseFieldDataSourceControl implements OnInit {
    options: {
        label?: any;
        value: any;
        required?: boolean;
        disabled?: boolean;
    }[];
    direction: 'row' | 'column';
    optionsContainerClass: string;
    singleSelect: boolean;
    dataSourceAction: (() => Observable<any>) | null;
    switchInput: boolean;
    onChange: EventEmitter<any>;
    constructor();
    selected: (string | number)[];
    ngOnInit(): void;
    handleChange(event: any, value: any): void;
    private convertBooleanToStringValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseCheckboxComponent, "app-base-checkbox", never, { "options": { "alias": "options"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "optionsContainerClass": { "alias": "optionsContainerClass"; "required": false; }; "singleSelect": { "alias": "singleSelect"; "required": false; }; "dataSourceAction": { "alias": "dataSourceAction"; "required": false; }; "switchInput": { "alias": "switchInput"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, never>;
}

declare class BaseDropdownComponent extends BaseFieldDataSourceControl implements OnInit {
    placeholder: string;
    searchable: boolean;
    onItemSelected: EventEmitter<any>;
    defaultValue: any;
    showClear: boolean;
    containerClass: string;
    dropdown: Select;
    selectedName: string;
    filterChange: Subject<string>;
    overlayWidth: number;
    constructor();
    ngOnInit(): void;
    onChange(event: any): void;
    getLabelByValue(value: string | number): string;
    onLazyLoad(event: {
        first: number;
        last: number;
    }): void;
    onShow(event: any): void;
    onClick(event: any): void;
    isObject(val: any): val is {
        icon: string;
        style?: IconStyle;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseDropdownComponent, "app-base-dropdown", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; }, { "onItemSelected": "onItemSelected"; }, never, never, true, never>;
}

declare class BaseInputComponent extends BaseFieldControlComponent implements OnInit {
    mode: 'text' | 'number' | 'password' | 'label-text' | 'email' | 'url' | 'phone' | 'chips';
    iconUrl: string;
    leftIconUrl: string;
    onBlurFunction: any;
    onlyNumber: boolean;
    maxLength: number;
    prefix: string;
    suffix: string;
    min: number;
    max: number;
    minFractionDigits: number;
    maxFractionDigits: number;
    useGrouping: boolean;
    content: string;
    descriptionMessage: string;
    labelTextStyle: string;
    autoFocus: boolean;
    iconLeftStyle: string;
    iconRightStyle: string;
    seperator: string;
    isValidPassword: boolean;
    prefix_content: ElementRef<HTMLDivElement>;
    paddingForPrefix: number;
    ngOnInit(): void;
    onBlur(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseInputComponent, "app-base-input", never, { "mode": { "alias": "mode"; "required": false; }; "iconUrl": { "alias": "iconUrl"; "required": false; }; "leftIconUrl": { "alias": "leftIconUrl"; "required": false; }; "onBlurFunction": { "alias": "onBlurFunction"; "required": false; }; "onlyNumber": { "alias": "onlyNumber"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; }; "useGrouping": { "alias": "useGrouping"; "required": false; }; "content": { "alias": "content"; "required": false; }; "descriptionMessage": { "alias": "descriptionMessage"; "required": false; }; "labelTextStyle": { "alias": "labelTextStyle"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "iconLeftStyle": { "alias": "iconLeftStyle"; "required": false; }; "iconRightStyle": { "alias": "iconRightStyle"; "required": false; }; "seperator": { "alias": "seperator"; "required": false; }; "isValidPassword": { "alias": "isValidPassword"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BaseFormComponent implements OnChanges, AfterContentChecked {
    private cfr;
    private sanitized;
    formConfig: FormConfig[];
    formItemContainer: ViewContainerRef[];
    formConfigSorted: any[];
    constructor(cfr: ChangeDetectorRef, sanitized: DomSanitizer);
    ngOnChanges(changes: SimpleChanges): void;
    private sortFollowOrder;
    updateConfig(item: FormConfig): FormConfig;
    ngAfterContentChecked(): void;
    bypassSecurityTrustHtml(innerHtml: string): _angular_platform_browser.SafeHtml;
    trackByRow(index: number, el: any): any;
    trackByCol(index: number, el: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormComponent, "app-base-form", never, { "formConfig": { "alias": "formConfig"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormItemComponent implements OnInit, OnDestroy {
    private allBaseUIComp;
    private formArray;
    formItemContainer: ViewContainerRef;
    private componentRef;
    destroy$: Subject<unknown>;
    fieldConfig: FormConfig;
    parentFieldConfig: FormConfig[];
    constructor(allBaseUIComp: any, formArray: any);
    ngOnInit(): void;
    private renderItem;
    private invokeDependent;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormItemComponent, "app-form-item", never, { "fieldConfig": { "alias": "fieldConfig"; "required": false; }; "parentFieldConfig": { "alias": "parentFieldConfig"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormArrayComponent implements OnInit, AfterViewInit {
    private formArrItemComp;
    private cdf;
    fields: FormArrayConfig[];
    fieldControl: FormArray;
    label: string;
    addBtnLabel: string;
    removeBtnLabel: string;
    container: QueryList<ViewContainerRef>;
    fieldConfigArr: any;
    formArrayValue: any;
    constructor(formArrItemComp: any, cdf: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    getFieldsConfig(index: number): any;
    handleAddForm(index: number): void;
    handleRemoveForm(i: number): void;
    private render;
    private buildOriginForm;
    private buildNewForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormArrayComponent, "app-base-form-array", never, { "fields": { "alias": "fields"; "required": false; }; "fieldControl": { "alias": "fieldControl"; "required": false; }; "label": { "alias": "label"; "required": false; }; "addBtnLabel": { "alias": "addBtnLabel"; "required": false; }; "removeBtnLabel": { "alias": "removeBtnLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormArrayItemComponent {
    removeBtnLabel: string;
    addBtnLabel: string;
    formConfig: FormConfig[];
    addForm: EventEmitter<any>;
    removeForm: EventEmitter<any>;
    handleAddForm(): void;
    handleRemoveForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormArrayItemComponent, "app-form-array-item", never, { "removeBtnLabel": { "alias": "removeBtnLabel"; "required": false; }; "addBtnLabel": { "alias": "addBtnLabel"; "required": false; }; "formConfig": { "alias": "formConfig"; "required": false; }; }, { "addForm": "addForm"; "removeForm": "removeForm"; }, never, never, true, never>;
}

declare class BaseMultiselectComponent extends BaseFieldDataSourceControl implements OnInit {
    showClear: boolean;
    showChips: boolean;
    multiselect: MultiSelect;
    filterChange: Subject<string>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    handleRemove(item: any): void;
    getChipLabel(item: any): string;
    onLazyLoad(event: {
        first: number;
        last: number;
    }): void;
    handleFilter(event: any): void;
    private override;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMultiselectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseMultiselectComponent, "app-base-multiselect", never, { "showClear": { "alias": "showClear"; "required": false; }; "showChips": { "alias": "showChips"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ChipComponent {
    sanitizer: DomSanitizer;
    label: string;
    removable: boolean;
    file: File;
    attachment: AttachmentDto;
    isFile: boolean;
    downloadable: boolean;
    styleClass: string;
    labelStyleClass: string;
    removeIconName: string;
    removeIconStyleClass: string;
    remove: EventEmitter<any>;
    isShowDIalog: boolean;
    safeGoogleDocsUrl: any;
    constructor(sanitizer: DomSanitizer);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onRemove(): void;
    previewFileClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipComponent, "app-chip", never, { "label": { "alias": "label"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "file": { "alias": "file"; "required": false; }; "attachment": { "alias": "attachment"; "required": false; }; "isFile": { "alias": "isFile"; "required": false; }; "downloadable": { "alias": "downloadable"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "labelStyleClass": { "alias": "labelStyleClass"; "required": false; }; "removeIconName": { "alias": "removeIconName"; "required": false; }; "removeIconStyleClass": { "alias": "removeIconStyleClass"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
}

declare class BaseRadioComponent extends BaseFieldDataSourceControl {
    options: {
        label?: any;
        value: any;
        preIcon?: string;
    }[];
    direction: 'row' | 'column';
    containerClass: string;
    inputContainerClass: string;
    labelClass: string;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseRadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseRadioComponent, "app-base-radio", never, { "options": { "alias": "options"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; "inputContainerClass": { "alias": "inputContainerClass"; "required": false; }; "labelClass": { "alias": "labelClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToastService {
    private messageService;
    private translateService;
    private toastListSubject;
    toastList$: rxjs.Observable<MessageModel[]>;
    private removeSubject;
    remove$: rxjs.Observable<string>;
    private toasts;
    constructor(messageService: MessageService, translateService: TranslateService);
    addSingle(toastConfig: MessageModel): void;
    private loadMessageData;
    addMultiple(toastConfig: MessageModel[]): void;
    clear(key?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
}

declare class ToastComponent implements OnInit {
    private toastService;
    private cdr;
    toastList: MessageModel[];
    enteredToasts: Record<string, boolean>;
    closingToasts: Record<string, boolean>;
    constructor(toastService: ToastService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    removeToast(key: string): void;
    trackByKey(_: number, toast: MessageModel): string;
    isClosing(key: string): boolean;
    hasEntered(key: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "app-toast", never, {}, {}, never, never, true, never>;
}

declare class BaseTextareaComponent extends BaseFieldControlComponent implements OnInit {
    lineNumber: number;
    maxLength: number;
    autoResize: boolean;
    labelShowsOptional: boolean;
    hideLengthLimit: boolean;
    instructionText: string;
    tooltip: string;
    autoFocus: boolean;
    currentLength: number;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTextareaComponent, "app-base-textarea", never, { "lineNumber": { "alias": "lineNumber"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "labelShowsOptional": { "alias": "labelShowsOptional"; "required": false; }; "hideLengthLimit": { "alias": "hideLengthLimit"; "required": false; }; "instructionText": { "alias": "instructionText"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BaseDatepickerComponent extends BaseFieldControlComponent implements OnInit, OnChanges {
    dateFormat: string;
    mode: 'range' | 'single' | 'range_2';
    placeholder: string;
    minDate: Date;
    maxDate: Date;
    view?: DatePickerTypeView;
    showTime: boolean;
    showSeconds: boolean;
    timeOnly: boolean;
    destroy$: Subject<boolean>;
    date_from: FormControl<any>;
    date_to: FormControl<any>;
    dateToErrorMessage: string;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: any): void;
    setDisabledRange(disabled: boolean): void;
    invalidDateFormat(format?: string): ValidatorFn;
    checkInvalidField(): boolean;
    checkInvalidDateToField(): boolean;
    customRequiredValidatorRange2: (control: AbstractControl) => {
        required: boolean;
    };
    IsArrayLabel(label: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDatepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseDatepickerComponent, "app-base-datepicker", never, { "dateFormat": { "alias": "dateFormat"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "view": { "alias": "view"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "timeOnly": { "alias": "timeOnly"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BreadcrumbComponent {
    private router;
    private activatedRoute;
    private translateService;
    homeLink: string;
    items: MenuItem[];
    home: MenuItem;
    constructor(router: Router, activatedRoute: ActivatedRoute, translateService: TranslateService);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    buildBreadCrumbs(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "app-breadcrumb", never, { "homeLink": { "alias": "homeLink"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BaseSwitchComponent extends BaseFieldControlComponent {
    content: string;
    inline: boolean;
    descriptionMessage: string;
    switchUpdate: EventEmitter<any>;
    constructor();
    inputSwitchOnClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseSwitchComponent, "app-base-switch", never, { "content": { "alias": "content"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "descriptionMessage": { "alias": "descriptionMessage"; "required": false; }; }, { "switchUpdate": "switchUpdate"; }, never, never, true, never>;
}

export { AttachmentDto, BASE_FORM_ITEMS_EVENT, BASE_UI_TOKEN, BaseButtonComponent, BaseCheckboxComponent, BaseDatepickerComponent, BaseDropdownComponent, BaseFieldControlComponent, BaseFormComponent, BaseInputComponent, BaseLabelComponent, BaseMultiselectComponent, BaseRadioComponent, BaseSwitchComponent, BaseTextareaComponent, BasedDto, BreadcrumbComponent, CONTROL_TYPE, CONTROL_TYPE_CODE, ChipComponent, FORM_ARRAY_ITEM_TOKEN, FORM_ARRAY_TOKEN, FormArrayComponent, FormArrayItemComponent, FormItemComponent, MessageModel, NUMBER_INPUT_FORMAT, NgBaseLib, ToastComponent, ToastService, isBaseButton };
export type { BaseButtonFormConfig, BaseCheckBoxFormConfig, BaseDataSourceAction, BaseDataSourceActionEvent, BaseDataSourceWithOptions, BaseDatepickerFormConfig, BaseDropdownFormConfig, BaseFormArrayConfig, BaseFormConfig, BaseHTMLFormConfig, BaseInputFormConfig, BaseInputTextConfig, BaseLabelFormConfig, BaseMenuItem, BaseMultiselectFormConfig, BaseRadioFormConfig, BaseSelectFormConfig, BaseSwitchFormConfig, BaseTabMenuItem, BaseTextAreaFormConfig, EditorToolbarSetupDto, FormArrayConfig, FormConfig, IconStyle, OptionsModel, ProtertiesDto, TableConfig, TreeOptionsModel, VirtualScrollConfig };