import { IMapDidChange } from 'mobx';
import { $SchemaIdTemplate, AttributeType, ElementSchema, ElementType, SchemaId, Stage, Template, TemplateId } from '../interfaces';
import { AttributeDefinition, AttributeDefinitions, AttributeFileData, AttributeGroup, AttributeValue, ConditionalViewConfig, ElementAttributeData, ElementData, ElementFormData, ElementRaw, ElementsPrivileges, ElementsTemplates, ElementTemplateV1, LocalElement, Operation, PlatformFile, PreparedFiles } from '../interfaces/element.interface';
import { DehydratedElement } from '../interfaces/offline.interface';
import { Element } from '../models/element';
import { BatchCreateResponse, BatchMetadata } from '../services/edocu/batch';
import { ElementGetQueryParams, ElementPrivileges, ElementSearchOptions, GetElementSearch } from '../services/edocu/elements';
import { MainStore } from './mainStore';
interface InstantiateElementOptions {
    setToMemory: boolean;
    extendWithOlderData: boolean;
}
type SyncProgress = {
    done: number;
    failed: number;
    total: number;
};
export declare function isValidDateString(date: string | undefined): boolean;
export declare class ElementStore {
    static listeners: (() => void)[];
    elementsTypeDataV1: Map<string, AttributeDefinitions>;
    elementTemplatesV1: ElementsTemplates;
    workRecordActions: Map<string, string[]>;
    elementSchemas: Map<SchemaId, ElementSchema>;
    elementTemplates: Map<string, Template>;
    privileges: ElementsPrivileges;
    elements: Map<string, Element>;
    syncProgress: SyncProgress | undefined;
    socketEventIds: string[];
    main: MainStore;
    constructor(main: MainStore);
    addTypeData(type: string, typeData: AttributeDefinitions): void;
    addWorkRecordActions(type: string, actions: string[]): void;
    search(query: string, options?: ElementSearchOptions): Promise<GetElementSearch | undefined>;
    addTemplateV1Data(type: string, organization: string, template: ElementTemplateV1): void;
    addPrivilegesData(type: ElementType, organization: string, privileges: ElementPrivileges): void;
    get<T extends Element>(hash: string, type: ElementType, queryParams?: ElementGetQueryParams): Promise<T | null>;
    getElementTypeData(type: string): Promise<AttributeDefinitions | undefined>;
    getElementTemplateV1(type: string, organization: string): Promise<ElementTemplateV1 | undefined>;
    getElementSchema(type: ElementType, options?: {
        stage?: Stage;
        useStoreCache?: boolean;
        cache?: false;
    }): Promise<ElementSchema | undefined>;
    setSchema(schemaId: SchemaId, schema: ElementSchema): void;
    saveSchema(type: ElementType, schema: ElementSchema, options?: {
        stage?: Stage;
    }): Promise<ElementSchema & {
        children?: ElementSchema[];
    }>;
    addSchema(schema: Required<Pick<ElementSchema, 'id' | 'scope' | 'properties'>>, options?: {
        stage?: Stage;
    }): Promise<ElementSchema>;
    getTemplate(type: ElementType, templateId?: string, options?: {
        stage?: Stage;
        useStoreCache?: boolean;
        cache?: false;
        strict?: boolean;
    }): Promise<Template | undefined>;
    saveTemplate(schemaId: SchemaId, templateId?: TemplateId, data?: Partial<Template>, options?: {
        stage?: Stage;
    }): Promise<Template>;
    setTemplate(schemaId: SchemaId, template: Template, templateId?: TemplateId): void;
    getElementPrivileges(type: ElementType, organization: string): Promise<ElementPrivileges | undefined>;
    loadElementTypes(right?: 'read' | 'update' | 'create'): Promise<string[]>;
    create(type: ElementType, data: ElementAttributeData, organization: string, options?: {
        parent?: Element;
        shouldLoad?: boolean;
    }): Promise<{
        hash: string;
    }>;
    createTicket(data: ElementAttributeData, organization: string): Promise<{
        hash: string;
    }>;
    createBatchElements(elements: LocalElement[]): Promise<BatchCreateResponse>;
    getLocalFiles(data: ElementAttributeData): PreparedFiles[];
    uploadFiles(type: ElementType, hash: string, files: PreparedFiles[], workRecordHash?: string): Promise<import("../services").ApiOkResponse<import("../interfaces").FileBatchResponse> | undefined>;
    onElementsChange(change: IMapDidChange<string, Element>): Promise<void>;
    onConnectionChange(): Promise<void>;
    syncLocalElements(): Promise<void>;
    saveElementToStorage(originalElement: Element): Promise<void> | undefined;
    removeElement(hash: string): Promise<void> | undefined;
    dehydrateElement(element: Element): DehydratedElement | undefined;
    rehydrateElement(hash: string): Promise<Element | undefined>;
    rehydrateElements(): Promise<void>;
    batchMetadata(elements: Element[], attributes: string[]): Promise<BatchMetadata<string> | undefined>;
    instantiateElementValue(value: AttributeValue): Element[];
    instantiateElement(hash: string, data?: ElementData | undefined, shouldLoad?: boolean, paramOptions?: Partial<InstantiateElementOptions>): Element | undefined;
    instantiateLocalElement(type: string, organization: string, data?: Omit<ElementData, '_type' | 'organization' | 'hash'>, parent?: Element): LocalElement;
    instantiateElementWithChildren(elementRaw: ElementRaw): Element;
    getModelForElementType(type?: ElementType): typeof Element;
    batchUpdateElements(elements: Element[], changes?: ElementFormData): Promise<import("../services").ApiOkResponse<void> | undefined>;
    getElementFromHash(hash: string, options?: {
        loadFullData?: boolean;
        forceLoad?: boolean;
    }): Promise<Element>;
    getElementFromQR: (url: string) => Promise<Element>;
    static areAllConditionsMet(conditions: ConditionalViewConfig['conditions'], element: Element): boolean;
    static getSolvedGroupVisibility(group: AttributeGroup, element: Element): boolean;
    static getSolvedGroupCollapse(group: AttributeGroup, element: Element): boolean;
    static getSolvedAttrVisibility(attributeDefinition: AttributeDefinition | {
        visibility: ConditionalViewConfig;
    }, element: Element): boolean;
    getAttributeType(type: ElementType, attributeKey: string): AttributeType | undefined;
    prepareOperations(type: ElementType, data: ElementAttributeData, oldData?: ElementAttributeData): Operation[];
    loadAndPersistBatchElements(hashes: string[], projection?: string[], paramOptions?: {
        setToMemory?: boolean;
    }): Promise<Element[]>;
    applyPatchToElement(element: Element, operations: Operation[]): void;
    subscribeToElementUpdates(element: Element): (() => void) | undefined;
    computeElementDataHash(data: ElementData): string;
    getFilesWithUniqNames(attributeValue: AttributeFileData): {
        localFiles: import("../interfaces").LocalFile<PlatformFile>[];
        conflictHashes: string[];
    };
}
export declare const getTemplateId: (schemaId: SchemaId, templateId?: string) => $SchemaIdTemplate;
export {};