import { Store, Reducer, AnyAction, Dispatch, Unsubscribe, Action } from 'redux';
import * as rxjs from 'rxjs';
import { Observable, Subscription } from 'rxjs';
import * as i0 from '@angular/core';
import { ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
import { User, ClientConfig, DocumentData, FormParameters, ComponentDocument, FormDocument, FormTemplate, ComponentDefinition, ErrorComponentDefinition, FormCustomElement, DocumentInfo, FormComponent, DocumentChangedInfo, FileReferenceDetails, OfflineStatus, PageDownloadProgress, LastTileSyncDetails, ChangeSourceType, StateChangeInfo } from '@formbird/types';
import { IndexedDB, IndexedDBConnector, IndexedDBKeyValueStorage } from '@formbird/indexed-db';
import { ActivatedRouteSnapshot } from '@angular/router';

/**
 * Custom equality checker that can be used with `.select` and `@select`.
 * ```ts
 * const customCompare: Comparator = (x: any, y: any) => {
 *  return x.id === y.id
 * }
 *
 * @select(selector, customCompare)
 * ```
 */
type Comparator$1 = (x: any, y: any) => boolean;
type Transformer$1<RootState, V> = (store$: Observable<RootState>, scope: any) => Observable<V>;
type PropertySelector$1 = string | number | symbol;
type PathSelector$1 = (string | number)[];
type FunctionSelector$1<RootState, S> = (s: RootState) => S;
type Selector$1<RootState, S> = PropertySelector$1 | PathSelector$1 | FunctionSelector$1<RootState, S>;
/** @hidden */
declare const sniffSelectorType: <RootState, S>(selector?: Selector$1<RootState, S>) => "function" | "nil" | "path" | "property";
/** @hidden */
declare const resolver: <RootState, S>(selector?: Selector$1<RootState, S>) => {
    property: (state: any) => any;
    path: (state: RootState) => any;
    function: FunctionSelector$1<RootState, S>;
    nil: (state: RootState) => RootState;
};
/** @hidden */
declare const resolveToFunctionSelector: <RootState, S>(selector?: Selector$1<RootState, S>) => FunctionSelector$1<RootState, S> | ((state: RootState) => RootState) | ((state: RootState) => any) | ((state: any) => any);
/**
 * Gets a deeply-nested property value from an object, given a 'path'
 * of property names or array indices.
 *
 * @hidden
 */
declare function getIn(v: any | undefined, pathElems: (string | number)[]): any | undefined;

/**
 * This interface represents the glue that connects the
 * subscription-oriented Redux Store with the RXJS Observable-oriented
 * Angular component world.
 *
 * Augments the basic Redux store interface with methods to
 * enable selection and fractalization.
 */
interface ObservableStore<StateType> extends Store<StateType> {
    /**
     * Select a slice of state to expose as an observable.
     *
     * @typeparam S
     * @param selector key or function to select a part of the state
     * @param [comparator] Optional
     * comparison function called to test if an item is distinct
     * from the previous item in the source.
     *
     * @returns An Observable that emits items from the
     * source Observable with distinct values.
     */
    select: <SelectedType>(selector: Selector$1<StateType, SelectedType>, comparator?: Comparator$1) => Observable<SelectedType>;
    /**
     * Carves off a 'subStore' or 'fractal' store from this one.
     *
     * The returned object is itself an observable store, however any
     * selections, dispatches, or invocations of localReducer will be
     * specific to that substore and will not know about the parent
     * ObservableStore from which it was created.
     *
     * This is handy for encapsulating component or module state while
     * still benefiting from time-travel, etc.
     */
    configureSubStore: <SubState>(basePath: PathSelector$1, localReducer: Reducer<SubState, AnyAction>) => ObservableStore<SubState>;
}

/**
 * Custom equality checker that can be used with `.select` and `@select`.
 * ```ts
 * const customCompare: Comparator = (x: any, y: any) => {
 *  return x.id === y.id
 * }
 *
 * @select(selector, customCompare)
 * ```
 */
type Comparator = (x: any, y: any) => boolean;
type Transformer<RootState, V> = (store$: Observable<RootState>, scope: any) => Observable<V>;
type PropertySelector = string | number | symbol;
type PathSelector = (string | number)[];
type FunctionSelector<RootState, S> = (s: RootState) => S;
type Selector<RootState, S> = PropertySelector | PathSelector | FunctionSelector<RootState, S>;

/**
 * This is the public interface of @formbird/services. It wraps the global
 * redux store and adds a few other add on methods. It's what you'll inject
 * into your Angular application as a service.
 */
declare abstract class AppStore<RootState> implements ObservableStore<RootState> {
    /** @hidden, @deprecated */
    static instance?: ObservableStore<any>;
    /**
     * Accepts a Redux store, then sets it in AppStore and
     * allows AppStore to observe and dispatch to it.
     *
     * This should only be called once for the lifetime of your app, for
     * example in the constructor of your root component. If configureStore
     * has been used this cannot be used.
     *
     * @param store Your app's store
     */
    abstract provideStore: (store: Store<RootState>) => void;
    abstract dispatch: Dispatch<AnyAction>;
    abstract getState: () => RootState;
    abstract subscribe: (listener: () => void) => Unsubscribe;
    abstract replaceReducer: (nextReducer: Reducer<RootState, AnyAction>) => void;
    abstract select: <SelectedType>(selector?: Selector<RootState, SelectedType>, comparator?: Comparator) => Observable<SelectedType>;
    abstract configureSubStore: <SubState>(basePath: PathSelector, localReducer: Reducer<SubState, AnyAction>) => ObservableStore<SubState>;
}

/** @hidden */
declare class RootStore<RootState> extends AppStore<RootState> {
    private store;
    private store$;
    constructor();
    provideStore: (store: Store<RootState>) => void;
    getState: () => RootState;
    subscribe: (listener: () => void) => Unsubscribe;
    replaceReducer: (nextReducer: Reducer<RootState, AnyAction>) => void;
    dispatch: Dispatch<AnyAction>;
    select: <SelectedType>(selector?: Selector$1<RootState, SelectedType>, comparator?: Comparator$1) => Observable<SelectedType>;
    configureSubStore: <SubState>(basePath: PathSelector$1, localReducer: Reducer<SubState, AnyAction>) => ObservableStore<SubState>;
    private setStore;
    private storeToObservable;
}

declare function appStoreFactory(): RootStore<unknown>;
declare class FormbirdServicesModule {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<FormbirdServicesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormbirdServicesModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormbirdServicesModule>;
}

/**
 * A constants object for constants that are used on the client-side only
 */
declare const ClientConstants: {
    FILTER: string;
    FILTERED_QUERY: string;
    HTTP_STATUS_LOGIN_REJECTED: number;
    OPERATION_TYPE_POST: string;
    OPERATION_TYPE_PUT: string;
    OPERATION_TYPE_DELETE: string;
    LAST_ENTERED_STATE_URL: string;
    OFFLINE_LOGOUT: string;
    URL_EQUAL_REPLACEMENT_STRING: string;
    TOGGLE_ID_LEFT: string;
    DOCUMENT_NEW: string;
    DOCUMENT_RENEW: string;
    DOCUMENT_SAVING: string;
    DOCUMENT_SAVED: string;
    DOCUMENT_CHANGED: string;
    DOCUMENT_DESTROYED: string;
    DOCUMENT_UPDATED: string;
    DOCUMENT_DELETED: string;
    DOCUMENT_LOADED: string;
    DOCUMENT_LOAD_ERROR: string;
    VALIDATE_FORM_FIELDS: string;
    DOCUMENT_FORM_UPDATED: string;
    PRESAVE_DOCUMENT_FORM_RESET: string;
    FORM_DETECT_CHANGES: string;
    URL_CLICKED: string;
    FORM_DIRTY_UPDATED: string;
    SPINNER_UPDATED: string;
    FORM_RESET: string;
    RULES_STATUS_STARTED: string;
    RULES_STATUS_DONE: string;
    VALIDATION_INTERVAL_TIME: number;
    VALIDATION_REQUIRED_KEY: string;
    VALIDATION_REQUIRED_MESSAGE: string;
    VALIDATION_MIN_LENGTH_KEY: string;
    VALIDATION_MIN_LENGTH_MESSAGE: string;
    VALIDATION_MAX_LENGTH_KEY: string;
    VALIDATION_MAX_LENGTH_MESSAGE: string;
    CHANGED_DOCUMENT_LIST_ID_KEY: string;
    FILE_SENT_EVENT_NAME: string;
    LOCAL_STORAGE_OFFLINE_STATUS_KEY: string;
    BEFORE_INSTALL_PROMPT: string;
    DOCUMENT_SAVE_STATUS: string;
    CHECK_UNSYNCED_DOCUMENTS: string;
    WEB_SOCKET_STATUS: string;
};

/**
 * constants for local storage keys
 */
declare const LocalStorageKeys: {
    LOGGED_IN_USER_ID: string;
    LOGGED_IN_USER: string;
    LOGGED_IN_ACCOUNT_CONTROL_DOCUMENT: string;
    USER_SETTINGS: string;
    COMMAND_BAR_CSS: string;
    APP_VERSION: string;
    CHECK_PUBLIC_USER: string;
    TITLE_PREFIX: string;
    SERVICE_WORKER_ACTIVATED: string;
    TOP_BAR_INITIALIZED: string;
};

declare class ControlStateConstants {
    static CONTROL_STATE_STORAGE_PREFIX: string;
    static CONTROL_STATE_SIDEBAR_TOGGLE: string;
    static CONTROL_STATE_SIDEBAR_TOGGLE_XS_SM: string;
}

declare const UrlBasePathUtil: {
    basePath: string;
    basePathWithSlashPrefix: string;
};
declare class UrlBasePathService {
    getBasePath(): string;
}

declare class VersionService {
    static compareVersions(version1: string, version2: string): number;
    static hasBreakingApiChanges(): boolean;
    static needsUpdate(appVersion: string): boolean;
    static checkServerVersion(): Promise<boolean>;
}

declare class LoggedInUserService {
    private http;
    private localStorageService;
    private pageVisibilityService;
    private appStore;
    private keyValueStorageService;
    private workerService;
    private userConfig;
    user$: Observable<User>;
    private user;
    private userConfigItemListeners;
    constructor();
    /**
     * get the id of the logged in user
     */
    getUserId(): any;
    /**
     * set the user on login
     * @param account - the account to set
     * @param setAsOfflineUser - whether to set this user as the offline user
     */
    setUser(account: any): Promise<void>;
    setUserControlDocument(controlDocument: any): void;
    getUserControlDocument(): any;
    loggedUserAccountControlDocument(): Observable<Object>;
    setUserAccountGroupConfigDocument(groupConfigDocument: any): void;
    loggedUserAccountGroupConfigDocument(): Observable<Object>;
    getUserAccountGroupConfigDocument(): any;
    /**
     * remove the user on logout
     * @param account the account
     */
    logoutUser(): void;
    private filterAcct;
    resetUser(): void;
    /**
     * Custom user configuration is saved in local storage so that they survive across logins.
     * To that end, they should only contain flags or basic values keeping in mind the
     * limited storage capacity of local storage.
     */
    getUserConfig(): Promise<any>;
    getUserConfigItem(key: any): any;
    setUserConfigItem(key: any, value: any): void;
    /**
     * Custom implementation for listening to changes in user config items. Originally this should
     * have been done via using StorageEventListener but unfortunately it fires events only if other
     * tabs had modified the offline storage.
     * @param key the key
     * @param listener the listener
     */
    addUserConfigItemListener(key: any, listener: any): void;
    isUserOfflineMode(): boolean;
    getLoggedInUser(): any;
    loadLoggedUser(): Promise<unknown>;
    setLoggedUser(): Promise<unknown>;
    observableUser(): Observable<User>;
    setUserConfigItems(items: any): Promise<unknown>;
    removeUserConfigItems(keys: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggedInUserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggedInUserService>;
}

declare class UserSettingsService {
    private localStorageService;
    private fillSettingsObject;
    saveSettings(templateId: any, name: any, settings: any, value: any): void;
    getSettings(templateId: any, name: any, settings: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingsService>;
}

interface SearchFilter {
    filter: boolean;
    queryToBeFiltered: string;
}
declare class SearchFilterService {
    private localStorageService;
    private searchFilter;
    private searchFilterSubject;
    searchFilter$: Observable<SearchFilter>;
    constructor();
    setQueryToBeFiltered(query: any): void;
    removeFilter(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchFilterService>;
}

declare class SearchService {
    private dataService;
    private configService;
    private offlineStatusService;
    results: {
        data: any[];
    };
    constructor();
    getInstance(): this;
    /**
     * Do Elastic search on server side. If the browser is offline, do searching indexedDB.
     * @param options consists of text, filter query to search
     * @param searchContext an object consists of additional params
     * @returns Promise
     */
    search(options: any, searchContext?: any): Promise<any>;
    generatePit(): Promise<Object>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
}

declare abstract class SynchronousStorageService {
    protected storage: Storage;
    protected urlBasePathService: UrlBasePathService;
    protected constructor();
    setItem(key: string, value: string): void;
    getItem(key: string): string;
    removeItem(key: string): void;
}

declare class LocalStorageService extends SynchronousStorageService {
    protected storage: Storage;
    constructor();
}

declare class SessionStorageService extends SynchronousStorageService {
    protected storage: Storage;
    constructor();
}

declare class DataService {
    private configService;
    private indexedDBConnectorService;
    private loggedInUserService;
    private restDataService;
    private offlineStatusService;
    private indexedDBService;
    private clientAccessService;
    private documentSessionService;
    private opfsCacheService;
    preferredService: any;
    secondaryService: any;
    user$: Observable<User>;
    user: User;
    isRunningPreviousSync: boolean;
    constructor();
    /**
     * cache a document for offline use
     * @param docInfo - the document used to load full document to cache
     * @param versions - the versions used to cache
     */
    cacheDocument(docInfo: any, versions: any): Promise<any>;
    documentExists(documentId: string, includeDeleted?: boolean): Promise<any>;
    /**
     * get a document
     */
    getDocument(id: string, expectedDocumentType?: string): Promise<any>;
    getTemplateAndDocument(id: string, templateId?: string): Promise<any>;
    getDocumentOfflineMode: (id: any, expectedDocumentType?: string) => Promise<any>;
    getDocumentFromServer: (id: string, expectedDocumentType?: string) => Promise<any>;
    private checkDocumentExistsOfflineMode;
    private checkDocumentExistFromServer;
    findByElastic(query: any, searchContext?: any): Promise<any>;
    generatePit(): Promise<Object>;
    aggregate(query: any): Promise<Object>;
    search(options: any, searchContext: any): Promise<any>;
    /** initialise the service passed in and return a promise for initialisation completion
     *
     * @param service - the service to initialise
     */
    initialiseService(service: any): any;
    terminateService(service: any): Promise<any>;
    /** set the versionId and previousVersionId fields */
    setVersionFields(document: any): void;
    private hasOfflineAccess;
    private isAccountDoc;
    jsonPatchUpdate(originalBean: any, newBean: any, updateOption?: any): Promise<any>;
    /**
     * Called in CacheLoadService.enable cache to re-arrange primary and secondary data service
     */
    initialise(): any;
    reset(): Promise<any>;
    deepDiffUpdate(originalBean: any, newBean: any, options?: any): Promise<any>;
    insert(bean: any, cachingRequired?: any): Promise<any>;
    destroy(id: any, templateId?: any, versionId?: any): Promise<any>;
    /**
     * load unsynced and cache documents into indexedDB
     */
    workerLoadDataCache(): Promise<any>;
    /**
     * load unsynced and cache documents into indexedDB
     * @param isInitialize - whether in the case the documents are cached in the first time
     */
    loadDataCache(isInitialize?: any): Promise<any>;
    clearData(): Promise<boolean>;
    backupData(isFirstTime?: any): Promise<unknown>;
    backupDataInChunks(chunkSize: number, processChunk: (chunk: any[]) => void): Promise<void>;
    getIndexedDBIndexes(): Promise<string[]>;
    undestroy(id: string): Promise<any>;
    bulkUploadDocuments(documents: any): Promise<any>;
    executeComponentFunction(options: any): Promise<any>;
    getTemplateAndDocumentOfflineMode: (id: any, templateId: any) => Promise<any>;
    loadFileAttachmentCache(): Promise<unknown>;
    /**
     restFunc: will pass RestDataService function
     offlineFunc: will pass IndexedDBService function
     args: will pass the arguments object described at https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
     */
    executeDataFunction: (onlineFunc: any, offlineFunc: any, ...args: any[]) => Promise<any>;
    loadComponentDoc(directiveName: any): Promise<unknown>;
    private cacheAttachedFilesOffline;
    private shouldSaveOffline;
    destroyFileFromCache: (fileReferenceDocument: any) => Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;
}

declare class RestDataService {
    private http;
    private loggedInUserService;
    private offlineStatusService;
    private indexedDBService;
    private documentSessionService;
    private configService;
    private workerService;
    private notificationService;
    checkDocumentExists(url: any, id: any, includeDeleted?: any): Promise<Object>;
    getTemplateAndDocument: (id: string, templateId?: string) => Promise<any>;
    getDocumentObservable(id: any, expectedDocumentType?: any): rxjs.Observable<Object>;
    getDocument(id: any, expectedDocumentType?: any): Promise<Object>;
    terminateDataCaching(): void;
    workerLoadDataCache(syncStartTime: any, isInitialize?: any): Promise<unknown>;
    private processCachingDocuments;
    getIndexedDBIndexes(): Promise<string[]>;
    private getFullRestURL;
    /**
     * As per 10539, we send the new document directly to the server and let it run jsonPatch.
     * For simplicity, other parameters from the old deep Update was
     * removed because the server can resolve them with just the newDocument value.
     *
     * @param newDocument the new document to update
     * @returns promise|*|jQuery.promise the promise
     */
    jsonPatchUpdate(newDocument: any, options: any): Promise<Object>;
    insert(bean: any, url: any): Promise<Object>;
    private setupRequestBody;
    destroy(id: any, url: any, cachingRequired: any, templateId: any, previousVersionId: any): Promise<Object>;
    generatePit(): Promise<Object>;
    aggregate(query: any): Promise<Object>;
    search(options: any): Promise<Object>;
    loadVersions(versionIds: any): Promise<any>;
    undestroy(id: any, url: any): Promise<Object>;
    bulkUploadDocuments(documents: any, url: any): Promise<Object>;
    executeComponentFunction(options: any): Promise<Object>;
    loadComponentDoc(componentName: any): Promise<Object>;
    loadFile(fileNo: string): Promise<Blob>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RestDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RestDataService>;
}

declare class ConfigService {
    constructor();
    clientConfig(): ClientConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
}

declare class ClientAccessService {
    private loggedInUserService;
    user$: Observable<User>;
    user: User;
    constructor();
    checkAccess(targetDocument: any, operation: any): boolean;
    hasPermission(targetDocument: any, operations: any): boolean;
    writeKeysToDocument(document: any, template: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClientAccessService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClientAccessService>;
}

declare class BroadcastService {
    private _eventBus;
    constructor();
    broadcast(key: any, data?: any): void;
    on<T>(key: any): Observable<T>;
}

declare class ComponentService {
    private notificationService;
    private templateHtmlService;
    private configService;
    private offlineStatusService;
    private dataService;
    loadedComponentDocs: {};
    loadedComponents: {};
    private loadedVendorLibs;
    loadVendorLibs(vendorLibs: any): Promise<void>;
    loadTemplateVendorLibs(template: any): Promise<void>;
    registerComponents(componentDefs: any, documentData: DocumentData, formParameters: FormParameters, user: User, vcr: ViewContainerRef, dynamicContainerComponent: any): Promise<void>;
    private getFileNamesFromVendorLib;
    /**
     * Load component document
     * @param directiveName the directive name
     * @returns the promise of component doc
     */
    loadComponentDoc(directiveName: any): Promise<any>;
    /**
     * whether the component has been loaded
     * @param directiveName the directive name
     * @returns the result
     */
    componentExists(directiveName: any): any;
    /**
     * whether the component doc has been loaded
     * @param directiveName the directive name
     * @returns the result
     */
    componentDocExists(directiveName: any): boolean;
    loadComponentDocAndVendorLibs(componentName: any): Promise<ComponentDocument>;
    createComponent(document: FormDocument, template: FormTemplate, formParameters: FormParameters, account: any, compDef: ComponentDefinition | ErrorComponentDefinition, key: number, isloadedComponentDocAndVendorLibs?: any): Promise<FormCustomElement>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentService>;
}

declare class DocumentService {
    private dataService;
    private clientAccessService;
    private unsavedDocumentService;
    private localStorageService;
    private appStore;
    private offlineStatusService;
    private restoreWIPDocument;
    /**
     * Return the cached document that can be the document getting from DB or successful created document on form
     * @param documentId the document Id
     * @returns the existing document
     */
    getExistingDocument(documentId: any): any;
    private callbackResult;
    private execFindDocument;
    /**
     * return the document using a promise. This will be used to load documents into the data that is bound to,
     * before determining whether the document is a template or other document
     * @param documentId
     * @param options
     * @param callback
     */
    getDocumentOnly(documentId: any, options?: any, callback?: any): Promise<any>;
    getTemplateAndDocument(id: string, templateId?: string): Promise<any>;
    getLoadedDocument(documentId: string): any;
    getLoadedTemplate(templateId: string): any;
    getAltTemplate(documentId: string): any;
    getloadedTemplateForDoc(document: any, formParameters: any): any;
    /**
     * get the document
     * @param documentId the document Id
     * @param documentData - the result. The result will be put under a data element in documentData so it can
     * be bound to
     * @returns promise
     */
    getDocument(documentId: string, documentData: any): Promise<any>;
    private setInitialValues;
    /**
     * initialise a new document. The documentId will be set straight away so it can be passed through to child
     * docs without waiting for the main document to be saved. This allows the save to be performed in one operation
     * and reduces the chance of the child doc being saved without having the parent id set
     * @param documentData the result inside documentData object
     */
    private initialiseNewDocument;
    /**
     * set the document in unsaved loaded docs and set the document to documentData.document. This will be used
     * to check for modifications and on saving the documents
     * @param document the data
     * @param unsavedDocumentListId the unsaved document list Id
     */
    private setInLoadedDocs;
    /**
     * set the template in unsaved loaded templates and set the template to documentData.template.This will be
     * used to store modified version of the template by rules
     * associate to its document.
     * @param template the data
     * @param unsavedDocumentListId the unsaved document list Id
     * @param orgTemplateId the org template
     */
    private setInLoadedTemplates;
    private updateDocumentData;
    private updateDocumentInfoProperties;
    private getTemplateForDocumentErrorDetails;
    getTemplateForDocument(formParameters: FormParameters, documentData: any): Promise<any>;
    getTemplateForDocument_OLD(formParameters: FormParameters, documentData: any): Promise<any>;
    private updateDisableSaveTemplate;
    /**
     * return the template for the document passed in
     * @param doc - the document to get the template for
     * @returns the template object
     */
    getTemplateFromDoc(doc: any): any;
    setLoadedTemplateOnly(tpl: any, versionId?: any): void;
    setAltTemplateInfo(documentId: any, templateId: any): void;
    setLoadedDocumentOnly(doc: any, versionId?: any): void;
    setOriginalDocumentOnly(doc: any, versionId?: any): void;
    /**
     * reset original doc to their clean state, with the latest copy of the original doc, so that any changes in
     * updates can be detected, also put new document after created successful on form.
     * @param doc - the doc to reset
     */
    resetOriginalDocument(doc: any): void;
    resetLoadedTemplate(templateId: any): void;
    /**
     * reset original version to their clean state, with the latest copy of the original doc, so that any changes in
     * updates can be detected, also put new document after created successful on form.
     * @param version - the version to reset
     */
    resetOriginalVersion(version: any): void;
    clearDocuments(): void;
    allDocuments(): any[];
    getDocuments(): any[];
    getOrgDocuments(): any;
    setInitialDocument(template: any, formParameters: any): any;
    setDisableSaveFieldDocument(document: any, template: any): void;
    getDisableSaveFieldDocument(documentId: string): any;
    resetDisableSaveFieldToDoc(doc: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentService>;
}

declare class TemplateService implements OnInit, OnDestroy {
    private currentDocumentService;
    private documentService;
    private dataService;
    documentData: any;
    sub: any;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    loadTemplate(doc: any, unsavedTemplates: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateService>;
}

declare class CurrentDocumentInfoService {
    private appStore;
    getStoreDocumentInfo(): DocumentInfo;
    getDocumentData(unsavedDocumentListId: any, selectedDocumentId: any, overrideTemplateId?: any): DocumentData;
    getMainDocumentListId(): string;
    getMainDocumentId(): any;
    getMainDocumentIdFromList(unsavedDocumentListId: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentDocumentInfoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CurrentDocumentInfoService>;
}

/**
 * This service stores the document data for the document on the attached main template.
 * It will be retrieved to navigate to document after creating from template, command bar buttons or left/right sidebar visibility...
 */
declare class CurrentDocumentService {
    private appStore;
    private currentDocumentInfoService;
    private documentService;
    documents$: Observable<any>;
    documentInfo$: Observable<any>;
    private documentData;
    private documentDataSubject;
    documentData$: Observable<DocumentData>;
    private mainUnsavedDocumentListId;
    private documentId;
    constructor();
    private updateDocumentData;
    /**
     * Set main document list and the attached main document
     * @param documentListId
     * @param documentId
     */
    setMainDocumentListId(documentListId: any, documentId: any): void;
    getMainDocumentListId(): string;
    getMainDocumentId(): string;
    getDocumentData(): DocumentData;
    /**
     * get the document from the main document - which is the document that the object nav bar is linked to
     */
    getDocument(): FormDocument;
    setDocument(document: any): void;
    /**
     * get the template from the main document - which is the document that the object nav bar is linked to
     */
    getTemplate(): FormTemplate;
    setTemplate(template: any): void;
    resetDocumentData(unsavedDocumentListId: any): void;
    resetInitDocumentData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CurrentDocumentService>;
}

declare class CurrentChildDocumentService {
    private appStore;
    private documentService;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentChildDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CurrentChildDocumentService>;
}

declare class UnsavedDocumentService {
    private appStore;
    private currentDocumentInfoService;
    /**
     * create a new unsaved document list. The unsaved document list is a list of documents that will be saved in a single
     * operation. This allows saving of documents independently of the nav bar save button. Eg. If you open up a dialog with a
     * template with a child doc then you need to save several documents on dialog close without saving the main document loaded
     * in the form. We can't put parameters in the save function to handle special cases like whether the save is for a dialog
     * because we would have to keep adding more special cases for saving from different locations.
     */
    createUnsavedDocumentList(isNewMainDocList?: any, existingUnsavedDocumentListId?: any): any;
    getDocumentInfo(documentListId: any): any;
    isModalDocument(documentListId: any): boolean;
    getDocumentListInfos(documentId: any): any[];
    /**
     * Get document information for each document inside a list. The result should be:
    {
      documentId: 'document-id',
      templateId: 'template-id',
      hierarchyInfo: {
        parentDocumentId: 'parent-document-id',
        childDocumentId: 'child-document-id'
      },
      options: {}
    }
     * @param documentListId
     * @param documentId
     * @returns
     */
    getDocumentInfoItem(documentListId: any, documentId: any): any;
    getUnsavedDocumentInfo(unsavedDocumentListId: any): any;
    /**
     * add a document to the list, so it will be included in the list of unsaved documents
     * @param document the document
     * @param unsavedDocumentListId the unsavedDocumentListId
     */
    addDocumentToUnsavedList(document: any, unsavedDocumentListId: any): void;
    /**
     * add a template to the list
     * @param template the template obj
     * @param unsavedDocumentListId the unsaved list
     * @param orgTemplateId the original template id
     */
    addTemplateToUnsavedList(document: any, template: any, unsavedDocumentListId: any, orgTemplateId: any): void;
    /**
     * get the document from the unsaved document list. The document will be set in the document parameter rather than returned
     * so that the document directly references the value in the unsaved list
     * @param documentResult - the document will be placed in the document parameter of documentResult. It needs to be done this
     *                         way because if you assign to an object directly, the reference that the object points at changes
     * @param unsavedDocumentListId the unsaved list Id
     * @param documentId the document Id
     */
    getDocument(documentResult: any, unsavedDocumentListId: any, documentId: any): void;
    /**
     * get the template from the unsaved document list. The template will be set in the template result parameter
     * rather than returned so that the template directly references the value in the unsaved list
     * @param documentResult - the template will be placed in the template parameter of documentResult. It needs to
     * be done this way because if you assign to an object directly, the reference that the object points at changes
     * @param unsavedDocumentListId the unsaved list Id
     * @param templateId the template Id
     */
    getTemplate(documentResult: any, unsavedDocumentListId: any, templateId: any, documentId: any): void;
    setDocument(unsavedDocumentListId: any, document: any): void;
    setTemplate(unsavedDocumentListId: any, documentId: any, template: any): void;
    /**
     * get the document from a unsaved document list.
     * @param documentId the document Id
     */
    getDocumentOnly(documentId: any): any;
    /**
     * get the template from the unsaved document list.
     * @param templateId the template Id
     */
    getTemplateOnly(templateId: any): any;
    setDocumentListOptions(unsavedDocumentListId: any, documentId: any, key: any, value: any): void;
    getDocumentListOptions(unsavedDocumentListId: any, documentId: any): any;
    getDocumentOptionKey(unsavedDocumentListId: any, documentId: any, optionKey: any): any;
    /**
     * Get the list of pair of document and template for each form. The result should be:
    [{
      document: document1,
      template: template1
    },
    {
      document: document2,
      template: template2
    }
    ]
     * @param unsavedDocumentListId
     * @returns
     */
    getUnsavedDocumentDatas(unsavedDocumentListId: any): any[];
    /**
     * get all the unsaved documents inside the provided document list
     * @param unsavedDocumentListId - the id of the list to get the loaded docs for
     */
    getUnsavedDocuments(unsavedDocumentListId: any): any[];
    getUnsavedDocumentId(unsavedDocumentListId: any): string;
    /**
     * get all the unsaved templates inside the privided document list
     * @param unsavedDocumentListId - the id of the document list to get all the loaded templates
     */
    getUnsavedTemplates(unsavedDocumentListId: any): any[];
    getUnsavedTemplate(documentId: any, unsavedDocumentListId: any): any;
    removeDocumentList(unsavedDocumentListId: any): void;
    /**
     * Get parent document and template
     * @param unsavedDocumentListId
     * @param childDocumentId
     */
    getParentData(unsavedDocumentListId: any, childDocumentId: any): any;
    setParentInfo(documentContext: any): void;
    setChildInfo(documentContext: any): void;
    /**
     * Get child document and template
     * @param unsavedDocumentListId
     * @param documentId
     */
    getChildData(unsavedDocumentListId: any, documentId: any): any;
    /**
       * store a document hierarchy info to a list. This will be needed when retrieve information to load a child
       * document from a parent one
       * @param hierarchyInfo (parentDocumentId and childDocumentId)
       * @param unsavedDocumentListId the unsaved list Id
       */
    updateDocumentListInfo(documentInfo: DocumentInfo, unsavedDocumentListId: any): void;
    clearDocuments(): void;
    getAllLoadedDocs(excludedOptions?: any): any[];
    getAllLoadedDocumentLists(): any[];
    documentIsLoaded(documentId: any): boolean;
    isDocumentsDefined(unsavedDocumentListId: any): boolean;
    getHierarchyInfo(unsavedDocumentListId: any, documentId: any): any;
    resetToOrgDocument(documentId: any, unsavedDocumentListId?: any): void;
    resetDocument(documentId: any, unsavedDocumentListId?: any): void;
    resetTemplateComponent(templateId: any, unsavedDocumentListId?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnsavedDocumentService>;
}

declare class ClientSystemHeaderService {
    private documentService;
    private getTemplate;
    updateSystemHeader(bean: any, template: any, originalBean: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClientSystemHeaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClientSystemHeaderService>;
}

declare class ChangedDocumentService {
    private appStore;
    private validationService;
    resetDocument$: Observable<any>;
    documents$: Observable<any>;
    recordedStateChanges$: Observable<any>;
    recordedComponentTemplateChanges$: Observable<any>;
    rulesProcessingData$: Observable<any>;
    private latestDocumentService;
    constructor();
    dispatchAction(action: Action): void;
    /**
     * Provide the change information for the specified document field that the component binds to
     * @param component the component binds to the field
     * @param newValue the changed/new value
     * @param controlName the registered control manages the field value
     * @param options the options
     */
    valueChanged(component: FormComponent, newValue: any, controlName?: string, options?: any): void;
    /**
     * A new way to notify changed value the same as @function valueChanged that provide the change information for the specified document field that the component binds to
     * @param documentId the document Id
     * @param changedFieldName the changed field name
     * @param newValue the changed/new value
     * @param formParameters form information
     * @param controlName the registered control manages the field value
     * @param options the options
     */
    notifyValueChanged(documentId: any, changedFieldName: any, newValue: any, formParameters: any, controlName?: any, options?: any): void;
    /**
       *
       * @param a documentChangedInfo
       */
    executeOnFieldChangeHasNoChanges(documentChangedInfo: DocumentChangedInfo): void;
    /**
     * @deprecated due to https://mantis.formbird.com/view.php?id=20113#c92502
     * @param component
     */
    executeOnFieldChangeWithNoChanges(component: FormComponent): void;
    resetChangeDocument(): void;
    notifyIntializedField(component: FormComponent, shouldDispatchEmptyFieldValue?: boolean): void;
    private isChangedFromTheSameSource;
    /**
     * Listen value changes on a specified document field
     * @param fieldName the field name of document
     * @param documentId the document id
     * @param controlName the registered control that holds the field value in this component. It is used to check on the source of change
     * to avoid applying changes itself and also applying the value from the components that share the field name.
     * @param options provides more information for the watch.
     */
    watch(fieldName: any, documentId: any, controlName?: string, options?: any): Observable<any>;
    watchComponentTemplate(templateId: any): Observable<any>;
    watchComponentDef(fieldName: any, templateId: any, componentName?: any): Observable<any>;
    watchDocument(documentId: any): Observable<any>;
    watchStoreChanges(): Observable<any>;
    watchComponentStateChanges(templateId: any): Observable<any>;
    notifyDocumentChanged(documentChangedInfo: DocumentChangedInfo): void;
    notifyComponentDefinitionUpdated(templateId: any, fieldName: any, key: any, componentDefinition: any): void;
    setOrgDocument(document: any): void;
    setDocumentInfo(unsavedDocumentListId: any, docInfo: DocumentInfo): void;
    setDocument(document: any): void;
    setComponentFlagTemplate(templateId: any, fieldName: any, flagName: any, flagValue: any): void;
    documentLoaded(documentId: any, unsavedDocumentListId: any, isLoaded: any): void;
    isLoadedDocument(documentId: any, unsavedDocumentListId: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangedDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChangedDocumentService>;
}

declare class ModifiedFieldService {
    private documentService;
    private clientAccessService;
    private unsavedDocumentService;
    private currentDocumentService;
    private broadcastService;
    user$: Observable<User>;
    user: User;
    modifiedFields: {};
    savingChangedData: {};
    formDirty: {
        showSpinner: boolean;
        isSaving: boolean;
        dirty: boolean;
        updateAllowed: boolean;
        validating: any;
    };
    constructor();
    private canUpdateDoc;
    /**
     * Check if the current form is dirty, that make the save button appear and blink or display unsaved changes dialog
     */
    isDirty(): boolean;
    shouldApplyFlags(documentListId: any): boolean;
    /**
     * Set current form to be dirty, that make the save button appear and blink
     * @param isDirty is dirty
     * @param documentId the document id
     */
    setDirty(isDirty: any, documentId?: any, unsavedDocumentListId?: any): void;
    setShowSpinner(showSpinner: any, unsavedDocumentListId?: any): void;
    /**
     * Allow this form to be updatable.
     * @param isAllowedUpdate is allowed update
     */
    setUpdateAllowed(isAllowedUpdate: any): void;
    /**
     * Reset the current form to its un-interacted state.
     */
    resetFormDirty(): void;
    /**
     * Sets the current form to be updatable depending on the current user's privileges.
     * @param docData the doc data object
     */
    setFormAccess(docData: any): void;
    isSaving(): boolean;
    setSaveFlag(isSaving: any, unsavedDocumentListId?: any): void;
    addModifiedField(documentId: any, changedFieldName: any, documentListId: any, shouldCompareDocuments?: any, overrideTemplateId?: any): boolean;
    resetModifiedFields(): void;
    removeModifiedDocumentFields(documentId: any): void;
    isPushing(documentId: any): any;
    setPushingData(isPushing: any, documentId: any): void;
    resetPushingData(documentId: any): void;
    removeAllSavingChangedDocumentFields(): void;
    assignChangedDocumentFields(document: any): void;
    removeTemplateFields(templateId: any): void;
    removeChangedField(documentId: any, changedFieldName: any): void;
    removeModifiedField(documentId: any, changedFieldName: any): void;
    isChangedField(documentId: any, changedFieldName: any, documentListId: any, overrideTemplateId?: any): boolean;
    /**
     * whether the document has unsaved changes
     * @param documentId the document id
     * @returns the result
     */
    hasChanged(documentId: any, unsavedDocumentListId?: any): boolean;
    /**
     * whether any documents have been changed
     * @returns the result
     */
    hasAnyChanged(): boolean;
    hasSavingChanged(documentId: any): string[];
    hasAnySavingChanged(): boolean;
    extractSavingChangedAsDocument(documentId: any): any;
    /**
     * get the unsaved documents for the unsaved document list. This needs to be separate from UnsavedDocumentService to avoid
     * a circular dependency of Angular service injections
     * @param unsavedDocumentListId - the id of the list to get the changed docs for
     */
    getModifiedDocuments(unsavedDocumentListId: any): any[];
    getChangedDocumentListId(documentId: any): any;
    getAllChangedDocumentListIds(): any[];
    /**
     * Get all the changed fields of the provided document.
     * @param documentId
     * @returns
     */
    getModifiedFieldsInDoc(documentId: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ModifiedFieldService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModifiedFieldService>;
}

declare class DocumentSaveService {
    private dataService;
    private notificationService;
    private documentService;
    private unsavedDocumentService;
    private currentDocumentService;
    private documentSessionService;
    private mandatoryFieldService;
    private modifiedFieldService;
    private validationService;
    private clientSystemHeaderService;
    private documentUpdateService;
    private configService;
    private broadcastService;
    private clientAccessService;
    private changedDocumentService;
    private finaliseValueService;
    private preProcessorFieldService;
    private appStore;
    private keyValueStorageService;
    private pendingOperationService;
    private loggedInUserService;
    private offlineStatusService;
    private savingEventBus;
    private savedEventBus;
    private savedDocs;
    documentData: any;
    constructor();
    private loadOverrideTemplate;
    private loadTemplate;
    private doPreSaveData;
    private doPostSaveData;
    private postSaveClientValidation;
    private shouldApplyFlags;
    private resetCleanStateDocument;
    private performPostSaveEach;
    private processSaveEach;
    private doSaveEach;
    setFlags(dirtyFlag: any, spinnerFlag: any, saveFlag: any, unsavedDocumentListId?: any): void;
    private doSave;
    private reloadDocumentAndApplyUpdates;
    save(unsavedDocumentListId: any): Promise<unknown>;
    saveDocumentLists(documentListIds: any): Promise<{
        data: any;
        error: any;
    }>;
    private broadcastSaving;
    onDocumentSaving(): rxjs.Observable<any>;
    private broadcastDocumentSaved;
    onDocumentSaved(): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentSaveService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentSaveService>;
}

declare class DocumentUpdateService {
    private dataService;
    private documentService;
    private modifiedFieldService;
    private unsavedDocumentService;
    private broadcastService;
    private configService;
    private validationService;
    private appStore;
    private offlineStatusService;
    private indexedDBService;
    private loggedInUserService;
    private updatePrevCurrentVersion;
    private executeOnFieldChangeOnPush;
    private extractChangedFields;
    updateVersions(versions: any): Promise<void>;
    applyDocumentChanges(oldOrgDoc: any, latestDoc: any, applyAllChanges?: any): Promise<any[]>;
    updateFormDocument(unsavedDocuments: any, doc: any): Promise<void>;
    applyDocumentChangesSimple(unsavedDocument: any, doc: any): void;
    checkDocumentsCreated(): Promise<void>;
    applyDocumentCreated(loadedDocument: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUpdateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentUpdateService>;
}

declare class MandatoryFieldService {
    private modifiedFieldService;
    constructor();
    mandatoryFields: {
        components: any[];
    };
    /**
     * @param fieldInput the input field
     * @param fld field
     * @returns the label that will be shown for mandatory fields that are missing
     */
    checkMandatoryValues(fieldInput: any, fld: any, isValidationArray: any): Promise<any>;
    /**
     * @param fieldInput the input field
     * @param fld field
     * @returns the label that will be shown for mandatory fields that are missing
     */
    checkMandatoryFields(fieldInput: any, fld: any): any;
    isMandatoryAnswered(unsavedDocumentDatas: any): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MandatoryFieldService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MandatoryFieldService>;
}

declare class FinaliseValueFieldService {
    private modifiedFieldService;
    private finaliseValueFunctions;
    private ensureTemplateExist;
    addFinaliseValueFunction(templateId: any, fieldName: any, func: any): void;
    getFinaliseValueFunction(templateId: any, fieldName: any): any;
    finaliseFieldValues(document: any, template: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FinaliseValueFieldService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FinaliseValueFieldService>;
}

declare class StorageEventService {
    private listeners;
    constructor();
    addListener(callback: any): void;
    private storage;
    start(): void;
    end(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StorageEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StorageEventService>;
}

declare class FileProviderService {
    private loggedInUserService;
    private indexedDBService;
    private offlineStatusService;
    private httpClient;
    private dataService;
    private configService;
    private clientAccessService;
    private appStore;
    private modifiedFieldService;
    private opfsCacheService;
    private currentDocumentService;
    private validationService;
    /**
     * Retrieves the file from offline storage first, if unsuccessful retrieve from server.
     */
    /**
     * Retrieves the file from offline storage first, if unsuccessful retrieve from server.
     */
    getFileResources(file: Pick<FileReferenceDetails, 'fileNo'> & Partial<Pick<FileReferenceDetails, 'fileName'>>): Promise<{
        base64strData: unknown;
        url: string;
    } | {
        url: string;
        base64strData?: undefined;
    }>;
    private getFile;
    /**
     * Sends the file directly to server.
     */
    onlineFileUpload(uploadConfig: any): Promise<{
        data: any;
    }>;
    private uploadFileToServer;
    private saveToServer;
    private createFileReferenceDocument;
    private updateFileReferenceDocument;
    private doPreSaveOffline;
    /**
     * Saves to offline database. The OfflinePoller sends it to the server later
     */
    private offlineFileUpload;
    private getFileDetails;
    downloadFile(file: any): void;
    private dataURLtoFile;
    uploadFile(uploadConfig: any): rxjs.Observable<unknown>;
    private updateFileInfo;
    private updateFileInfoFieldValue;
    updateSentFileToOfflineDoc(docId: any, processedFiles: any): Promise<void>;
    private doUpdateCachedObject;
    private shouldSaveOffline;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileProviderService>;
}

declare class IndexedDBPropertiesService {
    private loggedInUserService;
    private indexedDBService;
    private offlineStatusService;
    setItem(key: string, value: any): Promise<unknown>;
    getItem(key: string): Promise<unknown>;
    removeItem(key: string): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBPropertiesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBPropertiesService>;
}

declare class DexieSearchService {
    private indexedDBConnectorService;
    private getDatabase;
    search(query: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DexieSearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DexieSearchService>;
}

declare class OfflineStatusService {
    private loggedInUserService;
    private appStore;
    private keyValueStorageService;
    private sessionTestService;
    offlineStatus: OfflineStatus;
    private offlineStatusSubject;
    offlineStatus$: Observable<OfflineStatus>;
    pageDownloadProgress: PageDownloadProgress;
    constructor();
    initializeOfflineCounts(): Promise<void>;
    isInitialCachingComplete(): boolean;
    isOfflineMode(): boolean;
    getLastSyncDate(): number;
    setLastSyncDate(document: any): void;
    setOfflineStatusToLocalStorage(): Promise<void>;
    /**
     * Displays the loading cache status in the page
     * @param isCacheLoading
     * returns true if all pending documents had been cached.
     */
    setCacheLoadingStatus(isCacheLoading: any): boolean;
    isCacheLoading(): boolean;
    setConnected(): void;
    setDisconnected(): void;
    addToMaxCacheCount(count: any): void;
    setOperateOnline(operateOnline: boolean): void;
    shouldOperateOnline(): any;
    ignoreCacheDocument(doc: any): void;
    getErrorCacheCount(): number;
    initialCacheQuerySuccess(document: any): void;
    checkCurrentCacheCount(): void;
    setInitialCachingComplete(complete: any): void;
    setPendingDocumentCount(pendingCount: any): void;
    incPendingDocumentCount(): void;
    decPendingDocumentCount(): void;
    setPendingUploadCount(count: number): void;
    incPendingUploadCount(): void;
    decPendingUploadCount(): void;
    isConnected(): boolean;
    setCachingAppStatus(isCachingApp: any): void;
    setCurrentStaticResourceCount(count: number): void;
    setTotalStaticResourceCount(count: number): void;
    mergeOfflineStatusData(offlineStatus: any): void;
    checkServerConnectionStatus(): Promise<any>;
    getOfflineLoginConnectionPollTime(): any;
    setMaxCacheCount(count: any): void;
    setCachingEnabledStatus(enabled: boolean): void;
    isCachingEnabled(): boolean;
    checkErrorOfflineChangesSyncDocs(): Promise<void>;
    publishOfflineStatus(): void;
    getOfflineStatusFromKeyValueStorage(): Promise<OfflineStatus>;
    loadOfflineStatusFromKeyValueStorage(): Promise<OfflineStatus>;
    setLastTileSyncDetails(lastSyncDetails: LastTileSyncDetails): void;
    getLastTileSyncDetails(): LastTileSyncDetails;
    setAssetsCachingCompleted(completed: boolean): void;
    setDataCachingCompleted(completed: boolean): void;
    isDataCachingCompleted(): boolean;
    setMapTilesCachingCompleted(completed: boolean): void;
    checkCachingCompleted(): void;
    postMessageToServiceWorker(operateOnline: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OfflineStatusService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OfflineStatusService>;
}

declare class NotificationService {
    notyf: any;
    private queue;
    private currentMessage;
    private _scope;
    private _closeAllButton;
    private _closeAllThreshold;
    constructor();
    /**
     * position:
     *     { x: 'right', y: 'top' }
     *     { x: 'center', y: 'top' }
     *     { x: 'left', y: 'top' }
     *     { x: 'right', y: 'bottom' }
     *     { x: 'center', y: 'bottom' }
     *     { x: 'left', y: 'bottom' }
     *      /**
     *(e.g) position: { x: 'right', y: 'top' }
     *     notyf position options
     *     Param |       Type                | Details
     *     x     |  left ; center or right  | x-position
     *     y     | top  ; center or bottom  |  y-position
     */
    private ensureCloseAllButton;
    private printNotyfMessage;
    /**
     * position:
     *     { x: 'right', y: 'top' }
     *     { x: 'center', y: 'top' }
     *     { x: 'left', y: 'top' }
     *     { x: 'right', y: 'bottom' }
     *     { x: 'center', y: 'bottom' }
     *     { x: 'left', y: 'bottom' }
     *      /**
     *(e.g) position: { x: 'right', y: 'top' }
     *     notyf position options
     *     Param |       Type                | Details
     *     x     |  left ; center or right  | x-position
     *     y     | top  ; center or bottom  |  y-position
     */
    private printHTML5Notification;
    /**
     * Display both messages
     */
    printMessage(message: any, options?: any, title?: any, position?: any, preventDuplicate?: any, displayDesktopNotification?: any, onClickFunction?: any, timeOut?: any, isPermanent?: any, customClassName?: any): any;
    dismiss(notification: any): void;
    set(message: any): void;
    get(): {};
    error(message: any, title?: any, displayDesktopNotification?: any): void;
    forbidden(message: any, title?: any, displayDesktopNotification?: any): void;
    info(message: any, title?: any, displayDesktopNotification?: any): void;
    success(message: any, title?: any, displayDesktopNotification?: any): void;
    warning(message: any, title?: any, displayDesktopNotification?: any): void;
    setupAlert(scope: any, maxAlertMessages: any): void;
    reverseSetupAlert(): void;
}

declare class SearchQueue {
    private queue;
    private isProcessing;
    addToQueue(searchFunction: () => Promise<any>): void;
    processQueue(): Promise<void>;
}

declare class IndexedDBService extends IndexedDB implements OnDestroy {
    private http;
    private indexedDBConnectorService;
    offlineStatusService: OfflineStatusService;
    loggedInUserService: LoggedInUserService;
    private dexieSearchService;
    private clientAccessService;
    private broadcastService;
    notificationService: NotificationService;
    private keyValueStorageService;
    private dexieWorkerService;
    private opfsCacheService;
    private configService;
    private documentSessionService;
    private localStorageService;
    user: User;
    userSub: Subscription;
    searchQueue: SearchQueue;
    subscriptionMap: Map<string, Subscription>;
    constructor();
    constants: any;
    ngOnDestroy(): void;
    initialise(): Promise<any>;
    terminateService(): Promise<void>;
    search(options: any): Promise<unknown>;
    private _search;
    insert(bean: any): Promise<unknown>;
    destroy(id: any): Promise<unknown>;
    getDocument(id: any): Promise<unknown>;
    closeDatabase(): void;
    backupData(): Promise<any>;
    backupDataInChunks(chunkSize: number, processChunk: (chunk: any[]) => void): Promise<void>;
    clearData(): Promise<any>;
    /**
     * cache a document
     * @param document the document
     * @returns PromiseLike<any> the Promise
     */
    doCacheDocument(document: any, updateOfflineStatus: any): Promise<any>;
    private loadDocsById;
    private persist;
    /**
     * Cache the document in IndexedDB for offline use
     * @param document - the document to cache
     */
    cacheDocument(document: any, force: any): Promise<unknown>;
    /**
     * cache document received from websocket
     * @param docInfo - the info used to load full document and changed versions
     * @param versions - the versions of document
     * @param updateOfflineStatus - flag indicates that should update offline caching status
     * @returns Promise
     */
    cachePushedDocument(docInfo: any, versions: any, updateOfflineStatus?: any): Promise<unknown>;
    private getExistingDocument;
    private updateOfflineStatusForCachingAttachedFiles;
    cacheAttachedFilesOffline(document: any, updateOfflineStatus?: any): Promise<unknown>;
    toBase64Str(blob: any): Promise<unknown>;
    loadFileAsync(fileNo: any): Promise<unknown>;
    saveCacheObject(offlineCacheObject: any, callback: any): Promise<void>;
    private onDocumentUpdated;
    jsonPatchUpdate(newBean: any, originalBean: any, options: any): Promise<any>;
    private pushDocument;
    deepDiffUpdate(newBean: any, originalBean: any, options: any): Promise<any>;
    executeComponentFunction(options: any): Promise<unknown>;
    getTemplateAndDocument(id: string, templateId: any, callBack: any): Promise<void>;
    loadComponentDoc(componentName: any): Promise<unknown>;
    private removeDisableSaveFieldValues;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBService>;
}

declare class IndexedDBConnectorService extends IndexedDBConnector {
    private configService;
    private loggedInUserService;
    private pageVisibilityService;
    notificationService: NotificationService;
    private keyValueStorageService;
    private offlineStatusService;
    documentIndexes: any[];
    currentVersion: number;
    constructor();
    getLoggedInUserService(): LoggedInUserService;
    getDatabase(): Promise<any>;
    upgradeOfflineDatabase(indexes: any): void;
    upgradeIndexedDB(): Promise<any>;
    /**
     * open an IndexedDB cursor
     * @param cursorIndexName - the name of the index to open a cursor on
     * @param cursorRange - an IndexedDBKeyRange (part of the IndexedDB api) of the cursor to open
     * @returns promise.promise|*|jQuery.promise the promise
     */
    openCursor(cursorIndexName: any, cursorRange: any): Promise<unknown>;
    private createIndex;
    closeDatabase(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBConnectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBConnectorService>;
}

declare class FormColorService {
    color$: Observable<any>;
    private colorSubject;
    constructor();
    static COLOR_WHITE: string;
    color: {
        background: string;
        backgroundDark: string;
    };
    updateBackground(): void;
    setColor(formColor: any): void;
    setColorDark(formColorDark: any): void;
    setBackgroundColor(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormColorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormColorService>;
}

declare class ModifiedCSSService {
    private localStorageService;
    dynamicCSSObj: {
        commandBarCSS: any;
    };
    setCommandBarCSS(templateId: any, commandBarCSS: any): void;
    getStoredCommandBarCSS(templateId: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModifiedCSSService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModifiedCSSService>;
}

interface NavMenu {
    template: string;
    user: any;
    sideMenuOpen: boolean;
}
interface NavImage {
    homeButtonImage: any;
    homeButtonImages: any[];
}
declare class NavigationService implements OnInit, OnDestroy {
    private loggedInUserService;
    private defaultStateService;
    user$: Observable<User>;
    user: User;
    private menus;
    private menusSubject;
    menus$: Observable<NavMenu>;
    private images;
    private imagesSubject;
    images$: Observable<NavImage>;
    subs: Subscription;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    reset(): void;
    setCurrentTemplate(template: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
}

declare class DefaultStateService {
    private loggedInUserService;
    private router;
    private configService;
    user$: Observable<User>;
    user: User;
    constructor();
    isPathAccountDefault(): boolean;
    changeToDefaultState(nextState?: any, userBean?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultStateService>;
}

declare class CustomFieldPreprocessorService {
    private componentService;
    private offlineStatusService;
    private indexedDBService;
    preProcess(field: any, document: any): Promise<unknown>;
    private setSaveFlattenedValues;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFieldPreprocessorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CustomFieldPreprocessorService>;
}

declare class PreProcessorFieldService {
    private customFieldPreprocessorService;
    preProcessOneField(field: any, document: any): void;
    preProcessField(template: any, document: any): void;
    private isCustomPreProcessor;
    preProcess(template: any, document: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreProcessorFieldService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PreProcessorFieldService>;
}

declare const RelatedDocumentPreprocessor: {
    preProcess: (field: any, document: any) => void;
    formatValueInDocument: (tplItem: any, document: any) => void;
};

declare class ClientResourceService {
    private http;
    getClientResources(): Promise<Object>;
    getCachedFilesCount(): Promise<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClientResourceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClientResourceService>;
}

declare class RouterService {
    private injector;
    private service;
    constructor();
    getActivatedRouteSnapshot(): ActivatedRouteSnapshot;
    navigate(params: any[]): Promise<boolean>;
    navigateByUrl(url: string, target?: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RouterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RouterService>;
}

declare class ClientIncludeRuleSetService {
    private configService;
    private includeDocumentDataService;
    private notificationService;
    private loadIncludeDocs;
    addIncludesToRuleset(ruleFlow: any, callback: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClientIncludeRuleSetService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClientIncludeRuleSetService>;
}

declare class RuleContext {
    private currentEventName;
    private currentDocument;
    private currentTemplate;
    private currentDocumentContext;
    private affectedDoc;
    private affectedTpl;
    private superObj;
    constructor(superObj: any, eventName: any, processDoc: any, documentContext: any);
    getComponentDefinition(field: any): any;
    isVisible(field: any): boolean;
    showField(field: any, flag: any): void;
    showFields(fields: any, flag: any): void;
    enableField(field: any, flag: any): void;
    isEnabled(field: any): boolean;
    enableFields(fields: any, flag: any): void;
    filterAndSetAffectedDoc(fields: any): any[];
    isMandatory(field: any): boolean;
    mandateField(field: any, flag: any): void;
    mandateFields(fields: any, flag: any): void;
    setFieldValue(field: any, value: any, tmp: any): void;
    getFieldValue(field: any, tmp: any): any;
    checkChecklistItem(field: any, optionName: any, checked: any): void;
    getFilter(field: any): any;
    getGridFilter(field: any): any;
    setGridFilter(field: any, newFilter: any): void;
    setFilter(field: any, newFilter: any): void;
    openNewDocument(templateId: any, initialData: any, newWindow: any, callback: any): void;
    markDocumentChanged(): void;
    isNew(doc: any): boolean;
    determineAffectedDoc(field: any): any;
    /**
     * Set affected items: document, templateId, template item
     */
    setAffectedItems(docPrefix: any): void;
    setComponentProps(field: any, componentName: any, propertyValue: any): boolean;
    setFieldFlag(field: any, fieldFlag: any, flag: any): boolean;
    setFieldFlags(fields: any, fieldFlagName: any, flag: any): boolean;
    loadTplItem(fieldName: any): any;
    refreshComponentData(fieldName: any): void;
}

declare class RulesetContext {
    user: any;
    sharedValues: any;
    modalService: any;
    dataService: any;
    DataService: any;
    q: any;
    logger: any;
    ModalService: any;
    hasDuplicate: any;
    showNotification: any;
    /**
     * returns a boolean indicating whether the device is connected
     */
    isOnline: any;
    updateDocument: any;
    deleteDocument: any;
    findDocuments: any;
    findDocumentsByElastic: any;
    findDocumentsBySearch: any;
    addIncludesToRuleset: any;
    createDocumentFromTemplate: any;
    setSharedValue: any;
    getSharedValue: any;
    RulesetError: any;
    processSearchResults: any;
    showDialog: any;
    sanitizer: any;
    ModifiedFieldService: any;
    lazyLoader: any;
    loggedInUserService: any;
    clientIncludeRuleSetService: any;
    documentService: any;
    offlineStatusService: any;
    http: any;
    searchService: any;
    notificationService: any;
    clientAccessService: any;
    searchClientService: any;
    preProcessorFieldService: any;
    aggregate: any;
    isOnlineAsync: any;
    constructor();
    loadRecords(collectionName: any, callback: any): void;
    sanitizeHtml(html: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RulesetContext, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RulesetContext>;
}

declare class ClientRulesService {
    private dataService;
    private loggedInUserService;
    private clientIncludeRuleSetService;
    private documentService;
    private offlineStatusService;
    private http;
    private lazyScriptLoaderService;
    private searchService;
    private notificationService;
    private modifiedFieldService;
    private clientAccessService;
    private sanitizer;
    private searchClientService;
    private preProcessorFieldService;
    user$: Observable<User>;
    user: User;
    modalService: any;
    constructor();
    private sharedValues;
    expose(): Promise<RulesetContext>;
    private hasDuplicate;
    private showNotification;
    private updateDocument;
    private deleteDocument;
    private findDocuments;
    addIncludesToRuleset(ruleFlow: any, callback: any): void;
    private createDocumentFromTemplate;
    private aggregate;
    setSharedValue(key: any, value: any): void;
    getSharedValue(key: any): any;
    findDocumentsBySearch(query: any, userId: any, searchContext: any, options: any, callback: any): void;
    findDocumentsByElastic(query: any, userId: any, searchContext: any, options: any, callback: any): void;
    showDialog(message: any, errorType: any, succFunc: any, errorFunc: any, discardFunc: any): void;
    /** set the modal service. This is set from the application importing the @formbird/services
     *  library so that a native app can set its own implementation of ModalService
     */
    setModalService(modalService: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClientRulesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClientRulesService>;
}

declare class LatestDocumentService {
    private static instance;
    latestDocuments: any;
    constructor();
    static getInstance(): LatestDocumentService;
    getLatestDocument(documentId: string): any;
}

declare class ProxyEngineService {
    private static instance;
    latestDocumentService: LatestDocumentService;
    private constructor();
    static getInstance(): ProxyEngineService;
    setProxyForDocument: (originalDoc: any, documentContext: any, ruleEngine: any) => any;
}

declare class RuleEngineService {
    private clientRulesService;
    private configService;
    private localStorageService;
    private documentSessionService;
    private reduxStoreService;
    private ruleCacheService;
    private offlineStatusService;
    private loggedInUserService;
    private modifiedFieldService;
    private unsavedDocumentService;
    proxyEngineService: ProxyEngineService;
    constructor();
    processRuleFlow(document: any, documentContext: any, ruleFlowInfo: any, ruleScope: any, callback: any): Promise<void>;
    dispatchChangedAction(dispatchedChangedActions: any): void;
    attachChangedField(document: any, fldName: any, newValue: any, oldValue: any, documentContext: any): void;
    private isChangedTemplateFieldValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuleEngineService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuleEngineService>;
}

interface RulesetCacheInfo {
    rulesetId: string;
    rulesetScriptFunc: Function;
}
interface RulesetCache {
    [key: string]: RulesetCacheInfo;
}
declare class RuleCacheService {
    loadedRulesets: RulesetCache;
    constructor();
    setRuleset(documentId: string, rulesetScript: Function): void;
    getRuleset(documentId: string): RulesetCacheInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuleCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuleCacheService>;
}

declare class SessionTestService {
    private http;
    testSession(): Promise<any>;
    testSessionObservable(): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionTestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SessionTestService>;
}

declare class ControlStateSaveService {
    private sessionStorageService;
    setControlState(stateName: string, value: any): void;
    getControlState<T>(stateName: string): T;
    removeControlState(stateName: string): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ControlStateSaveService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ControlStateSaveService>;
}

/**
 * Angular: Load External JavaScript/Stylesheet File Dynamically
 */
declare class LazyScriptLoaderService {
    private readonly document;
    private vendorLibraryService;
    private loadedLibraries;
    loadScript(url: string): Promise<any>;
    loadStyle(url: string): Promise<any>;
    load(dependencies: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LazyScriptLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LazyScriptLoaderService>;
}

declare class PageVisibilityService {
    private visibilityListeners;
    private evtname;
    constructor();
    isHidden(): boolean;
    private visChange;
    startListeningForPageVisibility(): void;
    stopListeningForPageVisibility(): void;
    /**
     * Listeners should execute as fast as possible.
     *
     * It is the responsibility of the listener to implement its own debounce logic so to avoid unnecessary repetitive
     * execution.
     *
     * At the moment, debounce will not be implemented here to allow the listeners to react in the shortest
     * possible time.
     * @param listener the listener
     */
    registerVisibilityListener(listener: (isHidden: any) => void): void;
    removeVisibilityListener(listener: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageVisibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PageVisibilityService>;
}

declare class OfflineUtilService {
    private offlineStatusService;
    private broadcastService;
    private configService;
    private notificationService;
    private loggedInUserService;
    private indexedDBService;
    private restDataService;
    private webSocketService;
    private isPendingPreviousSync;
    constructor();
    getNextId(url?: any): any;
    startOfflinePoller(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OfflineUtilService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OfflineUtilService>;
}

declare class MandatoryValueProcessor {
    static processMandatoryValues(mandatoryValuesArray: any, fieldValue: any, label: any): Promise<any>;
}

declare class TabService {
    constructor();
    openNewDocument(templateId: string, initialData: any, newTab: string | boolean, callback: Function): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabService>;
}

declare class DynamicMetaTagService {
    private localStorageService;
    private metaDefaultTitle;
    private metaDefaultDesc;
    private metaDefaultImg;
    private metaTitleData;
    private metaDescData;
    private metaImgData;
    /**
     * set the meta tags in the html head of the page. This can be used by other applications to see details about the current
     * document in the page, eg. with document unfurling in Skype or Slack
     */
    set(title: any, description: any, img: any): void;
    title(): any;
    description(): any;
    image(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicMetaTagService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicMetaTagService>;
}

interface RulesData {
    eventName: string;
    document: any;
    documentContext: any;
    callback?: any;
    error?: any;
    results?: any;
    rulesetCount?: number;
    shouldRun?: boolean;
}
declare class ValidationService implements OnDestroy {
    private documentService;
    private unsavedDocumentService;
    private notificationService;
    private modifiedFieldService;
    private ruleEngineService;
    private currentDocumentService;
    private configService;
    private broadcastService;
    private tabService;
    private clientAccessService;
    private appStore;
    private keyValueStorageService;
    documentChangedInfo$: Observable<DocumentChangedInfo>;
    user$: Observable<User>;
    private subs;
    documentData: any;
    user: User;
    /***------------------- Exported data -------------------------***/
    validationCtrlValues: {};
    /***------------------- Local data ----------------------------***/
    eventList: {};
    private pendingSave;
    private queue;
    constructor();
    ngOnDestroy(): void;
    /***------------------- Exported functions --------------------***/
    loadValidators(tplItem: any, fieldName: any): any[];
    waitPendingEvents(save: any): void;
    setRuleStatusDone(templateId: any): void;
    private updateDocumentToStore;
    private handleOnFieldChange;
    executeOnFieldChangeWithNoChanges(documentChangedInfo: DocumentChangedInfo): void;
    private executeOnFieldChange;
    private validateChangedField;
    validateChangedFieldValues(scope: any, originValue: any, newValue: any, oldValue: any): void;
    preRenderDocument(document: any, docContext: any, callback: any): void;
    preDeleteClient(document: any, docContext: any, callback: any): void;
    onLoadDocument(document: any, docContext: any, callback: any): void;
    private doAuthRules;
    doPostLoginClient(document: any, docContext: any, callback: any): void;
    doPreLogoutClient(document: any, docContext: any, callback: any): void;
    private prepareFormParameters;
    onPreSaveDocument(document: any, docContext: any, callback: any): void;
    onPreSaveOfflineDocument(document: any, docContext: any, callback: any): void;
    onPostSaveClientDocument(document: any, docContext: any, callback: any): void;
    onReceiveDocument: (document: any, docContext: any, callback: any) => void;
    broadcastValidationEvent(): void;
    broadcastEvent(eventName: any, eventValue?: any): void;
    dispatchStoreAction(action: any): void;
    getTemplateFromStore(templateId: any): any;
    getDocumentFromStore(documentId: any): any;
    /***---------------------- Helper functions -----------------***/
    private initFieldValidator;
    executeRuleSet(eventName: any, processDoc: any, documentContext: any, eventRule: any): Promise<unknown>;
    private shouldRunRules;
    executeDocumentEventPromise(rulesData: RulesData): Promise<unknown>;
    executeDocumentEvent(eventName: any, document: any, documentContext: any, callback: any): void;
    private setParentTplDoc;
    private setChildTplDoc;
    private loadRulesetById;
    private loadRule;
    initValidationValue(document: any, template: any, field: any): void;
    private setValidationValue;
    private isExistsChangedFieldInRulesetTriggeredOn;
    /***------------------- End Rule context -------------------****/
    validateFormFields: (value?: any) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationService>;
}

declare class VendorLibraryService {
    constructor();
    getVendorLibrary(name: any): Promise<any>;
    getVendorLibs(): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VendorLibraryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VendorLibraryService>;
}

declare class UrlService {
    urls: any;
    constructor();
    getUrls(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<UrlService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UrlService>;
}

declare const FORM_SETUP_DOCUMENT_LIST = "FORM_SETUP_DOCUMENT_LIST";
declare const FORM_CHANGE_DOCUMENT = "FORM_CHANGE_DOCUMENT";
declare const FORM_RESET_CHANGE_DOCUMENT = "FORM_RESET_CHANGE_DOCUMENT";
declare const FORM_SET_DOCUMENT = "FORM_SET_DOCUMENT";
declare const FORM_SET_TEMPLATE = "FORM_SET_TEMPLATE";
declare const FORM_DELETE_DOCUMENT = "FORM_DELETE_DOCUMENT";
declare const FORM_UPDATE_COMPONENT_DEFINITION = "FORM_UPDATE_COMPONENT_DEFINITION";
declare const FORM_RESET_TEMPLATE_COMPONENT_DEFINITION = "FORM_RESET_TEMPLATE_COMPONENT_DEFINITION";
declare const FORM_SET_COMPONENT_FLAG_TEMPLATE = "FORM_SET_COMPONENT_FLAG_TEMPLATE";
declare const FORM_SET_COMPONENT_PROPS_TEMPLATE = "FORM_SET_COMPONENT_PROPS_TEMPLATE";
declare const FORM_SET_LIST_COMPONENTS_FLAG_TEMPLATE = "FORM_SET_LIST_COMPONENTS_FLAG_TEMPLATE";
declare const FORM_CLEAR_DOCUMENT = "FORM_CLEAR_DOCUMENT";
declare const FORM_RESET_TO_ORG_DOCUMENT = "FORM_RESET_TO_ORG_DOCUMENT";
declare const FORM_DOCUMENT_LOADED = "FORM_DOCUMENT_LOADED";
declare const FORM_SET_ORG_DOCUMENT = "FORM_SET_ORG_DOCUMENT";
declare const FORM_SET_ALT_TEMPLATE_INFO = "FORM_SET_ALT_TEMPLATE";
declare const FORM_SET_DOCUMENT_INFO = "FORM_SET_DOCUMENT_INFO";
declare const FORM_RESET_DOCUMENT_INFO = "FORM_RESET_DOCUMENT_INFO";
declare const FORM_UPDATE_INIT_DOCUMENT_DATA = "FORM_UPDATE_INIT_DOCUMENT_DATA";
declare const FORM_RESET_INIT_DOCUMENT_DATA = "FORM_RESET_INIT_DOCUMENT_DATA";
declare const FORM_SET_DISABLE_SAVE_FIELD_DOCUMENT = "FORM_SET_DISABLE_SAVE_FIELD_DOCUMENT";
declare const FORM_SET_DOCUMENT_SESSION = "FORM_SET_DOCUMENT_SESSION";
declare const FORM_SET_RULES_STATUS = "FORM_SET_RULES_STATUS";
/**
 * Document List section
 */
interface IFormSetupDocumentListAction extends Action {
    payload: {
        isNewMainDocList?: boolean;
        documentListId?: string;
    };
}
declare function formSetupDocumentList(isNewMainDocList?: boolean, documentListId?: string): IFormSetupDocumentListAction;
/**
 * Change document section
 */
interface IFormDocumentChangedAction extends Action {
    payload: {
        documentChangedInfo: DocumentChangedInfo;
    };
}
declare function formDocumentChanged(documentChangedInfo: DocumentChangedInfo): IFormDocumentChangedAction;
interface IFormResetDocumentChangedAction extends Action {
}
declare function formResetDocumentChanged(): IFormResetDocumentChangedAction;
/**
 * Clear document section
 */
interface IFormClearDocumentsAction extends Action {
}
declare function formClearDocuments(): IFormClearDocumentsAction;
/**
 * Set document section
 */
interface IFormSetDocumentAction extends Action {
    payload: {
        document: FormDocument;
        versionId?: string;
        source?: ChangeSourceType;
    };
}
interface IFormDeleteDocumentAction extends Action {
    payload: {
        documentId: string;
    };
}
interface IFormUpdateComponentDefinitionAction extends Action {
    payload: {
        templateId: string;
        fieldName: string;
        key: number;
        componentDef: ComponentDefinition;
    };
}
interface IFormResetTemplateComponentDefinitionAction extends Action {
    payload: {
        templateId: string;
    };
}
interface IFormSetComponentFlagAction extends Action {
    payload: {
        templateId: string;
        fieldName: string;
        flagName: string;
        flagValue: any;
        source?: ChangeSourceType;
    };
}
interface IFormSetComponentPropsAction extends Action {
    payload: {
        templateId: string;
        fieldName: string;
        componentName: string;
        propertyValue: any;
        source?: ChangeSourceType;
    };
}
interface IFormSetListComponentsFlagAction extends Action {
    payload: {
        templateId: string;
        fieldNames: any;
        flagName: string;
        flagValue: any;
        source?: ChangeSourceType;
    };
}
interface IFormResetToOrgDocumentAction extends Action {
    payload: {
        documentId: string;
    };
}
declare function formSetDocument(document: FormDocument, versionId?: string): IFormSetDocumentAction;
declare function formSetTemplate(document: FormDocument, versionId?: string): IFormSetDocumentAction;
declare function formUpdateComponentDefinition(templateId: any, fieldName: any, key: any, componentDef: any): IFormUpdateComponentDefinitionAction;
declare function formResetTemplateComponentDefinition(templateId: any, unsavedDocumentListId?: string): IFormResetTemplateComponentDefinitionAction;
declare function formSetComponentPropsTemplate(templateId: any, fieldName: any, componentName: any, propertyValue: any): IFormSetComponentPropsAction;
declare function formSetComponentFlagTemplate(templateId: any, fieldName: any, flagName: any, flagValue: any): IFormSetComponentFlagAction;
declare function formSetListComponentsFlagTemplate(templateId: any, fieldNames: any, flagName: any, flagValue: any): IFormSetListComponentsFlagAction;
declare function formSetOrgDocument(document: FormDocument, versionId?: string): IFormSetDocumentAction;
declare function formDeleteDocument(documentId: string): IFormDeleteDocumentAction;
declare function formResetToOrgDocument(documentId: string, unsavedDocumentListId?: string): IFormResetToOrgDocumentAction;
/**
 * Document info section
 */
interface IFormSetDocumentInfoAction extends Action {
    payload: {
        unsavedDocumentListId: string;
        documentInfo: DocumentInfo;
    };
}
declare function formSetDocumentInfo(documentListId: string, documentInfo: DocumentInfo): IFormSetDocumentInfoAction;
interface IFormResetDocumentInfoAction extends Action {
    payload: {
        unsavedDocumentListId: string;
    };
}
declare function formResetDocumentInfo(unsavedDocumentListId: string): IFormResetDocumentInfoAction;
interface IFormUpdateInitDocumentDataAction extends Action {
    payload: {
        unsavedDocumentListId: string;
        documentId: string;
        fieldName: string;
        fieldValue: any;
    };
}
declare function formUpdateInitDocumentData(unsavedDocumentListId: string, documentId: string, fieldName: string, fieldValue: any): IFormUpdateInitDocumentDataAction;
interface IFormResetInitDocumentDataAction extends Action {
    payload: {
        unsavedDocumentListId: string;
        documentId: string;
    };
}
declare function formResetInitDocumentData(unsavedDocumentListId: string, documentId: string): IFormResetInitDocumentDataAction;
interface IFormDocumentLoadedAction extends Action {
    payload: {
        documentId: string;
        unsavedDocumentListId: string;
        isLoaded: boolean;
    };
}
declare function formDocumentLoaded(documentId: string, unsavedDocumentListId: string, isLoaded: boolean): IFormDocumentLoadedAction;
interface IFormSetDisabledSaveAction extends Action {
    payload: {
        documentId: string;
        disabledFields: any;
    };
}
declare function formSetDisableSaveFieldDocument(documentId: string, disabledFields: any): IFormSetDisabledSaveAction;
interface IFormSetDocumentSessionAction extends Action {
    payload: {
        documentSession: any;
        documentId: string;
    };
}
declare function formSetDocumentSession(documentSession: any, documentId: string): IFormSetDocumentSessionAction;
interface IFormSetRulesStatusAction extends Action {
    payload: {
        templateId: string;
        status: string;
    };
}
declare function formSetRulesStatus(templateId: string, status: string): IFormSetRulesStatusAction;
interface IFormSetAltTemplateInfoAction extends Action {
    payload: {
        documentId: string;
        templateId: string;
    };
}
declare function formSetAltTemplateInfo(documentId: string, templateId: string): IFormSetAltTemplateInfoAction;

interface IFormNewState {
    resetDocument: string;
    documents: any;
    templates: any;
    orgDocuments: any;
    documentInfo: any;
    documentChangedInfo: DocumentChangedInfo;
    recordedStateChanges: StateChangeInfo;
    recordedComponentTemplateChanges: any;
    recordedDisableSaveFieldValues: any;
    documentSession: any;
    rulesProcessingData: any;
    altTemplateInfo: any;
}
declare function getDefaultFormNewState(): IFormNewState;

declare function formDocumentReducer(state: IFormNewState, action: Action): IFormNewState;

/**
 * Selects an observable from the store, and attaches it to the decorated
 * property.
 *
 * ```ts
 *  import { select } from '@formbird/services';
 *
 *  class SomeClass {
 *    @select(['foo','bar']) foo$: Observable<string>
 * }
 * ```
 *
 * @param selector
 * A selector function, property name string, or property name path
 * (array of strings/array indices) that locates the store data to be
 * selected
 *
 * @param comparator Function used to determine if this selector has changed.
 */
declare function select<T>(selector?: Selector<any, T>, comparator?: Comparator): PropertyDecorator;
/**
 * Selects an observable using the given path selector, and runs it through the
 * given transformer function. A transformer function takes the store
 * observable as an input and returns a derived observable from it. That derived
 *  observable is run through distinctUntilChanges with the given optional
 * comparator and attached to the store property.
 *
 * Think of a Transformer as a FunctionSelector that operates on observables
 * instead of values.
 *
 * ```ts
 * import { select$ } from 'angular-redux/store';
 *
 * export const debounceAndTriple = obs$ => obs$
 *  .debounce(300)
 *  .map(x => 3 * x);
 *
 * class Foo {
 *  @select$(['foo', 'bar'], debounceAndTriple)
 *  readonly debouncedFooBar$: Observable<number>;
 * }
 * ```
 */
declare function select$<T>(selector: Selector<any, T>, transformer: Transformer<any, T>, comparator?: Comparator): PropertyDecorator;

interface IApplicationState {
    formState?: IFormNewState;
}

declare function getStore(): Store;

declare class WebSocketService {
    private offlineStatusService;
    private unsavedDocumentService;
    private dataService;
    private restDataService;
    private documentUpdateService;
    private configService;
    private clientAccessService;
    private loggedInUserService;
    private socket;
    private getTransports;
    /**
     * cache any documents saved while offline. This can either be when the browser was closed or the device was offline
     */
    private loadDocumentsSavedWhileOffline;
    start(): void;
    /**
     * end the websocket session
     */
    end(): void;
    emit(eventName: any, data: any): void;
    addEventListener(eventName: any, eventHandlerFunc: any): void;
    removeEventListener(eventName: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketService>;
}

declare class DocumentSessionService {
    private appStore;
    documentSession$: Observable<any>;
    private subs;
    private documentSession;
    constructor();
    initialize(documentId: any): void;
    setDocumentSession(documentId: any, document?: any): void;
    getDocumentSession(documentId: string): any;
    /**
     * Clear the document session for a given document id
     * @param documentId - the document id to clear the session for
     */
    clearDocumentSession(documentId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentSessionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentSessionService>;
}

declare class KeyValueStorageService extends IndexedDBKeyValueStorage {
    private urlBasePathService;
    constructor();
    setItem(key: any, value: any): Promise<any>;
    getItem(key: any): Promise<any>;
    removeItem(key: any): Promise<any>;
}

declare class ModalService {
    ajsService: any;
    constructor();
    showDialog(message: any, messageType?: any, succFunc?: any, errorFunc?: any, discardFunc?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

declare class FormbirdInjectorService {
    injector: any;
    constructor();
    get(serviceName: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormbirdInjectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormbirdInjectorService>;
}

declare class CustomElementService {
    constructor();
    convertToCustomElement: (component: any, selector: any, injector: any, version?: any, options?: any) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomElementService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CustomElementService>;
}

declare class SearchQueriesService {
    constructor();
    getElasticQuery(scope: any, filter: any, search: any, columns: any, order: any, dtcolumns: any): any;
    getMongoQuery(scope: any, filter: any, search: any, columns: any, order: any, dtcolumns: any): any;
    getDexieQuery(scope: any, filter: any, search: any, columns: any, order: any, dtcolumns: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchQueriesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchQueriesService>;
}
declare class DatatablesQueriesService extends SearchQueriesService {
    static ɵfac: i0.ɵɵFactoryDeclaration<DatatablesQueriesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DatatablesQueriesService>;
}

declare class SclSearchClientConstantService {
    static operator: {
        equals: string;
        notEquals: string;
        contains: string;
    };
}
declare class SearchClientService {
    private httpClient;
    private searchService;
    private configService;
    private loggedInUserService;
    private offlineStatusService;
    private dataService;
    contextParams: any;
    search(options: any, searchContext?: any): Promise<unknown>;
    getDexieSearchFunction(options: any): Promise<void>;
    processDexieResults: (options: any, results: any, resolve: any) => Promise<void>;
    executeComponentFunction: (options: any, resolve: any, reject: any) => Promise<void>;
    getDexieQuery(queryName: any, callback: any): void;
    private filterResults;
    sortResults(options: any, documents: any): any;
    getDefaultSearchProvider(context: any): any;
    isDexieQuery(context: any, queryName?: any): any;
    isQueryDocumentExists(queryName: any, dataSource: any): Promise<unknown>;
    private parseOfflineFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchClientService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchClientService>;
}

interface PendingOperationOptions {
    documentId?: string;
    callerName?: string;
}
declare class PendingOperationService {
    private pendingOperations;
    private readonly documentSavePendingTimeoutMillis;
    addPendingOperation(operationName: string, options: PendingOperationOptions): void;
    markOperationComplete(operationName: string, options: PendingOperationOptions): void;
    waitForPendingOperations(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PendingOperationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PendingOperationService>;
}

declare class DexieWorkerService {
    private workerService;
    private worker;
    private resolveMap;
    private rejectMap;
    private pageId;
    private pendingQueries;
    initWorker(): void;
    search(idbName: string, currentVersion: number, documentIndexes: any, searchId: any, options: any): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DexieWorkerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DexieWorkerService>;
}

declare class WorkerService {
    private workers;
    addWorker(key: string, worker: Worker): void;
    getWorker(key: string): Worker | undefined;
    isWorkerTerminated(key: string): boolean;
    terminateWorker(key: string): void;
    terminateAllWorkers(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorkerService>;
}

export { AppStore, BroadcastService, ChangedDocumentService, ClientAccessService, ClientConstants, ClientIncludeRuleSetService, ClientResourceService, ClientRulesService, ClientSystemHeaderService, ComponentService, ConfigService, ControlStateConstants, ControlStateSaveService, CurrentChildDocumentService, CurrentDocumentInfoService, CurrentDocumentService, CustomElementService, CustomFieldPreprocessorService, DataService, DatatablesQueriesService, DefaultStateService, DexieSearchService, DexieWorkerService, DocumentSaveService, DocumentService, DocumentSessionService, DocumentUpdateService, DynamicMetaTagService, FORM_CHANGE_DOCUMENT, FORM_CLEAR_DOCUMENT, FORM_DELETE_DOCUMENT, FORM_DOCUMENT_LOADED, FORM_RESET_CHANGE_DOCUMENT, FORM_RESET_DOCUMENT_INFO, FORM_RESET_INIT_DOCUMENT_DATA, FORM_RESET_TEMPLATE_COMPONENT_DEFINITION, FORM_RESET_TO_ORG_DOCUMENT, FORM_SETUP_DOCUMENT_LIST, FORM_SET_ALT_TEMPLATE_INFO, FORM_SET_COMPONENT_FLAG_TEMPLATE, FORM_SET_COMPONENT_PROPS_TEMPLATE, FORM_SET_DISABLE_SAVE_FIELD_DOCUMENT, FORM_SET_DOCUMENT, FORM_SET_DOCUMENT_INFO, FORM_SET_DOCUMENT_SESSION, FORM_SET_LIST_COMPONENTS_FLAG_TEMPLATE, FORM_SET_ORG_DOCUMENT, FORM_SET_RULES_STATUS, FORM_SET_TEMPLATE, FORM_UPDATE_COMPONENT_DEFINITION, FORM_UPDATE_INIT_DOCUMENT_DATA, FileProviderService, FinaliseValueFieldService, FormColorService, FormbirdInjectorService, FormbirdServicesModule, IndexedDBConnectorService, IndexedDBPropertiesService, IndexedDBService, KeyValueStorageService, LatestDocumentService, LazyScriptLoaderService, LocalStorageKeys, LocalStorageService, LoggedInUserService, MandatoryFieldService, MandatoryValueProcessor, ModalService, ModifiedCSSService, ModifiedFieldService, NavigationService, NotificationService, OfflineStatusService, OfflineUtilService, PageVisibilityService, PendingOperationService, PreProcessorFieldService, ProxyEngineService, RelatedDocumentPreprocessor, RestDataService, RouterService, RuleCacheService, RuleContext, RuleEngineService, SclSearchClientConstantService, SearchClientService, SearchFilterService, SearchQueriesService, SearchService, SessionStorageService, SessionTestService, StorageEventService, TabService, TemplateService, UnsavedDocumentService, UrlBasePathService, UrlBasePathUtil, UrlService, UserSettingsService, ValidationService, VendorLibraryService, VersionService, WebSocketService, WorkerService, appStoreFactory, formClearDocuments, formDeleteDocument, formDocumentChanged, formDocumentLoaded, formDocumentReducer, formResetDocumentChanged, formResetDocumentInfo, formResetInitDocumentData, formResetTemplateComponentDefinition, formResetToOrgDocument, formSetAltTemplateInfo, formSetComponentFlagTemplate, formSetComponentPropsTemplate, formSetDisableSaveFieldDocument, formSetDocument, formSetDocumentInfo, formSetDocumentSession, formSetListComponentsFlagTemplate, formSetOrgDocument, formSetRulesStatus, formSetTemplate, formSetupDocumentList, formUpdateComponentDefinition, formUpdateInitDocumentData, getDefaultFormNewState, getIn, getStore, resolveToFunctionSelector, resolver, select, select$, sniffSelectorType };
export type { Comparator$1 as Comparator, FunctionSelector$1 as FunctionSelector, IApplicationState, IFormClearDocumentsAction, IFormDeleteDocumentAction, IFormDocumentChangedAction, IFormDocumentLoadedAction, IFormNewState, IFormResetDocumentChangedAction, IFormResetDocumentInfoAction, IFormResetInitDocumentDataAction, IFormResetTemplateComponentDefinitionAction, IFormResetToOrgDocumentAction, IFormSetAltTemplateInfoAction, IFormSetComponentFlagAction, IFormSetComponentPropsAction, IFormSetDisabledSaveAction, IFormSetDocumentAction, IFormSetDocumentInfoAction, IFormSetDocumentSessionAction, IFormSetListComponentsFlagAction, IFormSetRulesStatusAction, IFormSetupDocumentListAction, IFormUpdateComponentDefinitionAction, IFormUpdateInitDocumentDataAction, NavImage, NavMenu, PathSelector$1 as PathSelector, PropertySelector$1 as PropertySelector, RulesData, RulesetCache, RulesetCacheInfo, SearchFilter, Selector$1 as Selector, Transformer$1 as Transformer };