import { CookieService } from 'ngx-cookie';
import * as i3 from '@angular/forms';
import { NgForm, FormGroup, FormBuilder } from '@angular/forms';
import * as i0 from '@angular/core';
import { ElementRef, Renderer2, OnInit, AfterViewInit, OnDestroy, EventEmitter, ChangeDetectorRef, ComponentFactoryResolver, Injector, ApplicationRef } from '@angular/core';
import { Observable } from 'rxjs';
import { DateFnsService, NgxRouterService } from '@adins/fe-core';
import * as i11 from '@angular/router';
import { Router, ActivatedRoute } from '@angular/router';
import { HttpClient } from '@angular/common/http';
import * as i2 from '@angular/common';
import { LocationStrategy } from '@angular/common';
import { ToastrService } from 'ngx-toastr';
import * as i12 from '@adins/ucform';
import { FormAddressService, FormLookupService, UcFormSettingService } from '@adins/ucform';
import { FormArrayLookupService, UcFormArraySettingService } from '@adins/ucformarray';
import { MatDialogRef, MatDialog } from '@angular/material/dialog';
import { Ucattribute2Service } from '@adins/ucattribute2';
import { UcsearchFormService } from '@adins/ucsearch';
import * as i4 from '@ng-bootstrap/ng-bootstrap';
import * as i5 from '@adins/uc-directive-upper-case';
import * as i6 from '@adins/ucpaging';
import * as i7 from '@adins/ucgridview';
import * as i8 from '@adins/ucviewgeneric';
import * as i9 from '@adins/uc-subsection';
import * as i10 from '@adins/uctable';
import * as i13 from '@angular/material/tabs';
import * as i14 from '@adins/ucupload';
import * as i15 from '@adins/ucaddtotemp';

declare class ContainerService {
    private Module;
    private enjiForm;
    private form;
    constructor();
    setModule(module: any): void;
    getComponent(className: string): any;
    setEnjiForm(enjiForm: any): void;
    getEnjiForm(): NgForm;
    setForm(formGroup: FormGroup): void;
    getForm(): FormGroup<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContainerService>;
}

declare class TempSelectionService {
    private readonly key;
    private maps;
    constructor();
    setList(list: any[]): Map<string, any[]>;
    getList(): any[];
    remove(key: string): boolean;
    clearAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TempSelectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TempSelectionService>;
}

interface Config {
    target: string;
    alias?: string;
    methodName: string;
    args: {
        [key: string]: any;
    };
}
declare class ExecutorService {
    private executor;
    constructor();
    setExecutor(alias: string, executor: any): void;
    getExecutor(alias: string): any;
    invokeMethod(config: Config, params: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExecutorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExecutorService>;
}

declare class LogService {
    _environment: Record<string, any>;
    constructor();
    set environment(env: Record<string, any>);
    get environment(): Record<string, any>;
    get Instance(): this;
    log(message: any, obj?: any): void;
    error(message: any, obj?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
}

interface Message {
    type: string;
    data?: any;
}
declare class BroadcastReceiverService {
    private channel;
    private message;
    event: Observable<Message>;
    constructor();
    pub(message: Message): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastReceiverService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BroadcastReceiverService>;
}

declare class ActiveSessionService {
    private router;
    private cookieService;
    private receiver;
    private Identity;
    private routerSub;
    private broadcaster;
    private askRefresh;
    private elementRef;
    private renderer;
    private hasAlert;
    constructor(router: Router, cookieService: CookieService, receiver: BroadcastReceiverService);
    initialize(elementRef: ElementRef, renderer: Renderer2): void;
    dispatchEvent(event: CustomEvent): void;
    logout(): void;
    unsubscribe(): void;
    private alertSessionChange;
    private clearSession;
    private setIdentity;
    private validate;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveSessionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActiveSessionService>;
}

declare class ScrollToErrService {
    screenWindow: Element;
    formValidate(form: any): void;
    scrollIfFormHasErrors(form: any): Promise<any>;
    private scrollToError;
    private scrollTo;
    private filterFormEl;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToErrService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollToErrService>;
}

declare class UcTemplateService {
    private dateFnsService;
    private _environment;
    private _envConfig;
    private _urlConstant;
    private _pathConstant;
    private _navConstant;
    private _listEnvironments;
    private _dateService;
    private _containerService;
    private _callbackSubject;
    private _subscription;
    private _baseUrl;
    private _urlEnviPaging;
    private _apiQryPaging;
    private _addrEnviUrl;
    callback: Observable<any>;
    listMapComponent: Record<string, Map<any, {
        type: string;
        component: any;
        conditions?: any[];
    }>>;
    multiLangChannel: BroadcastChannel;
    constructor(dateFnsService: DateFnsService);
    set baseUrl(baseUrl: string);
    get baseUrl(): string;
    set environment(environment: any);
    get environment(): any;
    set envConfig(envConfig: any);
    get envConfig(): any;
    set urlConstant(urlConstant: any);
    get urlConstant(): any;
    set pathConstant(pathConstant: any);
    get pathConstant(): any;
    set listEnvironments(listEnvironments: any[]);
    set navConstant(navConstant: any);
    get navConstant(): any;
    get listEnvironments(): any[];
    set dateService(dateService: DateFnsService);
    get dateService(): DateFnsService;
    get container(): ContainerService;
    get event(): any;
    set module(module: any);
    set urlEnviPaging(url: string);
    get urlEnviPaging(): string;
    set apiQryPaging(url: string);
    get apiQryPaging(): string;
    set addrEnviUrl(url: string);
    get addrEnviUrl(): string;
    getCookie(cookieService: CookieService, key: string): any;
    /** Publish event callback to observer */
    publish(ev: any): void;
    listener(pageId: string, event: any): void;
    subscribe(): void;
    unsubscribe(): void;
    setListMapComponent(id: any, item: any): void;
    setLanguageSubContext(context: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UcTemplateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UcTemplateService>;
}

interface FunctionHandler {
    beforeSave?: () => boolean;
    afterSave?: (result: any) => void;
    beforeNext?: () => any;
    callback?: (event: any) => void;
}

interface BaseTemplate {
    pageName: string;
    handler?: FunctionHandler;
}

declare class NGXToastrService {
    toastr: ToastrService;
    constructor(toastr: ToastrService);
    typeSuccess(): void;
    typeInfo(): void;
    typeWarning(): void;
    typeError(): void;
    typeCustom(): void;
    progressBar(): void;
    timeout(): void;
    dismissToastOnClick(): void;
    clearToast(): void;
    showCloseButton(): void;
    enableHtml(): void;
    titleClass(): void;
    messageClass(): void;
    errorMessage(msg: any): void;
    typeSave(msg: any): void;
    typeErrorCustom(msg: any): void;
    successMessage(msg: any): void;
    warningMessage(msg: any): void;
    infoMessage(msg: any): void;
    errorAPI(status: any, reason: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NGXToastrService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NGXToastrService>;
}

interface Condition {
    property: string;
    restriction: string;
    value: any;
}

interface Case {
    conditions: Condition[];
    result: LinkAction | HttpAction | FunctionAction | ToasterAction | ModalAction | SwitchAction;
}

interface Action {
    type: ActionType;
}
interface ToasterAction extends Action {
    mode: string;
    message: string;
}
interface CommonAction extends Action {
    target: string;
    params: PropValue[];
}
interface LinkAction extends CommonAction {
    environment?: string;
    path: string;
}
interface FunctionAction extends CommonAction {
    alias: string;
    methodName: string;
}
interface HttpAction extends Action {
    environment: string;
    path: string;
    reqObj: PropValue[];
    onSuccess: Case[];
    onError: ToasterAction;
    mapResToDict: any[];
    excObj: {
        key: string;
    }[];
}
interface SwitchAction extends Action {
    breakIfFound?: boolean;
    cases: Case[];
}
interface ModalAction extends Action {
    isTemplate: boolean;
    width: string;
    backdropClass: string;
    disableClose: boolean;
    component: string;
    params: PropValue[];
    refreshFrom: any;
    affectedTable: string;
    mapObj: {
        propName: string;
        propValue: string;
    }[];
    excObj: {
        key: string;
    }[];
}
interface PropValue {
    propName: string;
    propValue: string;
}
declare enum ActionType {
    Link = "link",
    Http = "http",
    Function = "function",
    Modal = "modal",
    Toaster = "toaster",
    Switch = "switch",
    Callback = "callback",
    Confirm = "confirm",
    Reload = "reload",
    LocalStorage = "localStorage",
    SimpleCallback = "simpleCallback"
}

interface Button {
    id: string;
    key: string;
    displayName: string;
    btnType: "button" | "submit";
    position: string;
    icon: string;
    cssClass: string;
    action: LinkAction | HttpAction | FunctionAction | ToasterAction | ModalAction | SwitchAction;
    conditions: Condition[];
}

declare class LocalStorageService {
    private Storage;
    constructor();
    remove(key: string): void;
    clear(): void;
    create(key: string, data: any): void;
    createOrUpdate(key: string, data: any, index?: number, before?: any): void;
    find(key: string): any;
    get size(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
}

declare class UcTemplateComponent implements OnInit, AfterViewInit, OnDestroy {
    private fb;
    private router;
    private activeRoute;
    private http;
    private cookieService;
    private location;
    private AddressService;
    private cdr;
    private LookupService;
    private LookupFAService;
    private resolver;
    private injector;
    private appRef;
    private toastr;
    private FormSettingService;
    private FormArraySettingService;
    private templateService;
    private listTempService;
    private executor;
    private dialog;
    refData: any;
    private LocalStorage;
    private attrService;
    private ngxRouter;
    private scrollToErrFormSvc;
    private logger;
    private ucsearchFormService;
    private dateFnsService;
    data: EventEmitter<any>;
    Form: FormGroup;
    pageName: string;
    isDialog: boolean;
    isStepper: boolean;
    container: {
        key: string;
        component: any;
    }[];
    params: Record<string, any>;
    handler?: FunctionHandler;
    selfCustom: boolean;
    dialogRef: MatDialogRef<any>;
    idx: any;
    selectedIdxChange: EventEmitter<any>;
    parentDicts: Record<string, any>;
    notify: EventEmitter<any>;
    notifyUpdateTableFooter: EventEmitter<any>;
    notifyUpdateTable: EventEmitter<any>;
    onBtnClick: EventEmitter<any>;
    next: EventEmitter<any>;
    cbLookupManual: EventEmitter<string>;
    dictionary: EventEmitter<Record<string, any>>;
    onFormCreated: EventEmitter<FormGroup>;
    onRefresh: EventEmitter<any>;
    notifyUpdateDict: EventEmitter<any>;
    notifyUpdateViewFileUpload: EventEmitter<any>;
    notifyOnReadyForm: EventEmitter<any>;
    onDismissModal: EventEmitter<any>;
    context: EventEmitter<UcTemplateComponent>;
    private controlObservable;
    private formSubject;
    formObserver: Observable<any>;
    private callbackSub;
    pageTitle: string;
    templateObj: any;
    callbackAction: EventEmitter<any[]>;
    enjiForm: NgForm;
    listMapComponent: Map<any, {
        type: string;
        component: any;
        conditions?: any[];
    }>;
    listMapTypeToIdComponent: Map<string, {
        id: string;
        componentObj: any;
    }>;
    componentTypes: string[];
    listIds: any[];
    userAccess: any;
    isFormReady: Record<string, boolean>;
    queryParams: any;
    RowVersion: any;
    hideSubmitButton: boolean;
    hideCancelButton: boolean;
    overrideSubmitBtnText: string;
    isModeAdd: boolean;
    isHumanApproval: boolean;
    onSubmit: any;
    cacheable: boolean;
    pageCache: Record<string, any>;
    ApvReady: boolean;
    ApvRfaReady: boolean;
    IsAdd: boolean;
    serviceUrl: any;
    formCriteria: any[];
    topBtns: any[];
    botBtns: any[];
    initialValue: {};
    formOnLoadAct: Record<string, object>;
    pagePath: string;
    customClass: {
        [key: string]: string;
    };
    lookupMap: {
        [key: string]: any;
    };
    listIsVisible: Record<string, boolean>;
    selectedTabIndex: number;
    AppStep: Record<string, number>;
    StepIndex: number;
    StepCode: string;
    StepperView: any;
    StepperObj: any;
    copyNotify: any;
    dicts: Record<string, any>;
    TabList: Record<string, any[]>;
    notifyUpdateFormArray: EventEmitter<any>;
    notifyUpdateView: EventEmitter<boolean>;
    notifyUpdatePaging: EventEmitter<any>;
    onDestroyForm: EventEmitter<boolean>;
    private formValueChangesSubscription;
    private formSubscription;
    private readonly environment;
    private readonly envi;
    private navigationSubscription;
    constructor(fb: FormBuilder, router: Router, activeRoute: ActivatedRoute, http: HttpClient, cookieService: CookieService, location: LocationStrategy, AddressService: FormAddressService, cdr: ChangeDetectorRef, LookupService: FormLookupService, LookupFAService: FormArrayLookupService, resolver: ComponentFactoryResolver, injector: Injector, appRef: ApplicationRef, toastr: NGXToastrService, FormSettingService: UcFormSettingService, FormArraySettingService: UcFormArraySettingService, templateService: UcTemplateService, listTempService: TempSelectionService, executor: ExecutorService, dialog: MatDialog, refData: any, LocalStorage: LocalStorageService, attrService: Ucattribute2Service, ngxRouter: NgxRouterService, scrollToErrFormSvc: ScrollToErrService, logger: LogService, ucsearchFormService: UcsearchFormService, dateFnsService: DateFnsService);
    ngOnDestroy(): void;
    createInitialFormValue(): Promise<void>;
    ngAfterViewInit(): Promise<void>;
    ngOnInit(): void;
    notifyContainerChanges(next: any): void;
    getPage(params: any, dataSnapshot: any, isStepper: any): void;
    getTemplate(name: string, isComponent?: boolean): void;
    resetDictionary(templateObj?: any): void;
    onPageInit(templateObj: any): Promise<void>;
    private setLanguageContext;
    private loadPersistentDatatable;
    private storeLocalStorage;
    transformCustomComponent(templateObj: any): Promise<void>;
    render(): Promise<void>;
    compile(components: any[], type?: string): Promise<void>;
    getSetEditObj(formId: any, formObj?: any): Promise<void>;
    getParentInfo(): Promise<void>;
    getComponentType(id: any): string;
    getComponent(id: any, enjiForm?: NgForm): any;
    getTabComponent(id: string, tab: any, enjiForm?: NgForm): any;
    isVisible(id: string): boolean;
    getCssClass(key: string): string;
    hasFormComponent(): boolean;
    getListTemp(ev: any): void;
    getFormValue(isRaw?: boolean): any;
    refreshView(): void;
    updateViewFileDocLength(ev: any): void;
    notifyUpdateViewFileUploadFromModal(ev: any): void;
    SaveForm(): void;
    beforeSave(): boolean;
    afterSave(data: any, redirectUrl?: any): void;
    doSave(request: any): void;
    onSubmitModal(): void;
    checkServiceUrl(env: string, path: string): boolean;
    back(redirectUrl?: string): void;
    callbackLookup(property: string): void;
    callbackUpdateFormArr(ev: any): void;
    callbackUpdateDict(ev: any): void;
    callbackOnReadyForm(ev: any): void;
    callback(ev: any): Promise<void>;
    btnListener(key: string, button: Button): void;
    detectChanges(property: string): void;
    navigateUrl(nextUrl: string, params: any, state: any): void;
    private objectTransformer;
    private actionResult;
    private localStorageAction;
    private confirmAction;
    private linkAction;
    private modalAction;
    private funAction;
    private httpAction;
    onNext(ev: {
        Actions: any[];
        Data?: any;
        Event?: any;
    }): void;
    onDictionary(data: Record<string, any>): void;
    private switchAction;
    private toasterAction;
    private baseUrl;
    private getValue;
    switchCase(conditions: Condition[]): boolean;
    isBtnVisible(button: Button): boolean;
    gotoAddPage(): void;
    onChangeTab(id: string, ev: any): void;
    private compileTemp;
    private compileStepper;
    private compileTabs;
    private chooseStep;
    private compileContainer;
    private compileFormArray;
    private compileFileUpload;
    private compileViewFileUpload;
    private compileUpload;
    private compileReport;
    private compileGridView;
    private compilePaging;
    private compileAttr;
    private compileForm;
    private inflateView;
    private setLookupObject;
    private compileView;
    private compileCreateRfa;
    private constructCreateRfa;
    private waitFor;
    private waitForInterval;
    private compileCreateRfaManualDeviation;
    private compileApprovalHistory;
    private compileApprovalGeneralInfo;
    private compileApproval;
    private compileApprovalMulti;
    private setApprovalTypesAndAttributes;
    private setApprovalObjReason;
    private parseTitle;
    private getPanel;
    private ChangeTab;
    private NextStep;
    private getNextIndex;
    private getNextIndexByValue;
    private getKeyByIndex;
    private isLastStep;
    private parseDate;
    private isNumber;
    private isBoolean;
    private parseValue;
    private generateParams;
    private transformToObject;
    private cleansingParams;
    private textManipulation;
    private transformStringValue;
    private isStringManipulation;
    private buildUrl;
    private openUrl;
    private getServiceUrl;
    private invokeFunction;
    private httpExecutor;
    private publishDictionary;
    private removeFormControl;
    private flattenObject;
    private setBorderRadius;
    private FormatDateToYYYYMM;
    closeDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UcTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UcTemplateComponent, "adins-uctemplate", never, { "data": { "alias": "data"; "required": false; }; "Form": { "alias": "Form"; "required": false; }; "pageName": { "alias": "pageName"; "required": false; }; "isDialog": { "alias": "isDialog"; "required": false; }; "isStepper": { "alias": "isStepper"; "required": false; }; "container": { "alias": "container"; "required": false; }; "params": { "alias": "params"; "required": false; }; "handler": { "alias": "handler"; "required": false; }; "selfCustom": { "alias": "selfCustom"; "required": false; }; "dialogRef": { "alias": "dialogRef"; "required": false; }; "idx": { "alias": "idx"; "required": false; }; "selectedIdxChange": { "alias": "selectedIdxChange"; "required": false; }; "parentDicts": { "alias": "parentDicts"; "required": false; }; "notify": { "alias": "notify"; "required": false; }; "notifyUpdateTableFooter": { "alias": "notifyUpdateTableFooter"; "required": false; }; "notifyUpdateTable": { "alias": "notifyUpdateTable"; "required": false; }; }, { "onBtnClick": "onBtnClick"; "next": "next"; "cbLookupManual": "cbLookupManual"; "dictionary": "dictionary"; "onFormCreated": "onFormCreated"; "onRefresh": "onRefresh"; "notifyUpdateDict": "notifyUpdateDict"; "notifyUpdateViewFileUpload": "notifyUpdateViewFileUpload"; "notifyOnReadyForm": "notifyOnReadyForm"; "onDismissModal": "onDismissModal"; "context": "context"; }, never, never, false, never>;
}

declare class UcTemplateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UcTemplateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UcTemplateModule, [typeof UcTemplateComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i3.FormsModule, typeof i4.NgbModule, typeof i5.UcDirectiveUpperCaseModule, typeof i6.UcpagingModule, typeof i7.UcgridviewModule, typeof i8.UcviewgenericModule, typeof i9.UcSubsectionModule, typeof i10.UctableModule, typeof i4.NgbModalModule, typeof i4.NgbCollapseModule, typeof i11.RouterModule, typeof i12.UcformModule, typeof i13.MatTabsModule, typeof i14.UcuploadModule, typeof i15.UcaddtotempModule], [typeof UcTemplateComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UcTemplateModule>;
}

export { ActiveSessionService, BroadcastReceiverService, ContainerService, ExecutorService, LogService, ScrollToErrService, TempSelectionService, UcTemplateComponent, UcTemplateModule, UcTemplateService };
export type { BaseTemplate, FunctionHandler };