import { Http, Response } from '@angular/http';
import { DataEntity } from './data-entity.class';
import { DataEntityCollection } from './data-entity-collection.class';
import { ExternalInterface } from './external-interface/external-interface.interface';
import { Observable } from "rxjs/Rx";
import { ReplaySubject } from "rxjs/Rx";
import { ConfigProvider } from "./config.provider";
import { DataManagerConfig } from "./data-manager-config.interface";
import 'rxjs/add/operator/filter';
import 'rxjs/add/operator/map';
export declare class DataManagerService {
    http: Http;
    configProvider: ConfigProvider;
    private interfaces;
    entitiesCollectionsCache: {
        [key: string]: DataEntityCollection;
    };
    entitiesCollectionsSubjects: {
        [key: string]: ReplaySubject<DataEntityCollection>;
    };
    pendingCollectionsSubjects: {
        [key: string]: ReplaySubject<DataEntityCollection>;
    };
    entitiesSubjects: {
        [key: number]: ReplaySubject<DataEntity>;
    };
    pendingEntitiesSubjects: {
        [key: number]: ReplaySubject<DataEntity>;
    };
    enabledEndPoints: {
        [key: string]: boolean;
    };
    configuration: DataManagerConfig;
    constructor(http: Http, configProvider: ConfigProvider);
    createInterfaceByKey(interfaceType: string, conf: any): ExternalInterface;
    createInterfaces(conf: DataManagerConfig): void;
    useLocale(locale: string): void;
    getInterface(endPointName: string): ExternalInterface;
    getNesting(entityName: string, key: string): any;
    /**
     * Charge une collection d'entités
     * @param entityType Type d'entité à charger
     * @param forceLoading Force le chargement depuis provider de données (pas de cache front)
     * @param fields
     * @param params
     * @returns {Observable<DataEntityCollection>} L'observable de chargement
     */
    loadEntityCollection(entityType: string, forceLoading?: boolean, fields?: Array<string>, params?: Object): Observable<DataEntityCollection>;
    /**
     * Charge une entité de données
     * @param entityType Type d'entité
     * @param entityId Id de l'entité
     * @param forceLoading Force le chargement depuis le provider de données (pas de cache front)
     * @returns {Observable<DataEntity>} L'observable de chargement
     */
    loadEntity(entityType: string, entityId: any, forceLoading?: boolean, nesting?: boolean): Observable<DataEntity>;
    getEntity(entityType: string, forceLoading?: boolean): Observable<DataEntity>;
    addTest(collection: DataEntityCollection): DataEntityCollection;
    /**
     * On propage les changements vers les observables des entités de même id
     * @param entity L'entité à propager
     */
    propagateEntityChange(entity: DataEntity): void;
    /**
     * Propage les modifications de la collection vers les autres collection de même type
     * @param collection La collection à propager
     */
    propagateCollectionChange(collection: DataEntityCollection): void;
    /**
     * Sauvegarde les donnnées d'une entitée vers le provider de données
     * @param entity L'entité à sauvegarder
     * @param propagateChanges
     * @returns {Observable<DataEntity>} L'observable de sauvegarde
     */
    saveEntity(entity: DataEntity, propagateChanges?: boolean, raw?: boolean, applyDiff?: boolean, exclusions?: string[]): Observable<DataEntity>;
    checkAndRegisterEntity(entity: DataEntity): Observable<DataEntity>;
    createTemporaryEntity(entityType: string, datas: Object): DataEntity;
    /**
     * Crée une nouvelle entité d'un type donné dans le provider de données
     * @param entityType Type de l'entité à créer
     * @param datas Données d'initialisation
     * @returns {Observable<DataEntity>} L'observable de création
     */
    createEntity(entityType: string, datas: Object, params?: Object, temporary?: boolean, exclusions?: string[]): Observable<DataEntity>;
    /**
     * Put entity
     * @param entityType
     * @param datas
     * @param params
     * @returns {ReplaySubject<DataEntity>}
     */
    putEntity(entityType: string, datas: Object, params?: Object): Observable<DataEntity>;
    nextOnCollection(entityType: any): void;
    /**
     * Supprime une entité dans le provider de données
     * @param entity Entité à supprimer
     * @param params
     * @returns {Observable<Response>} L'observable de suppression
     */
    deleteEntity(entity: DataEntity, params?: Object): Observable<Response>;
    getEntityIndexInCollection(entity: DataEntity): number;
    deleteAction(entity: DataEntity): void;
    /**
     * Duplique une entité dans le provider de données
     * @param entity L'entité à dupliquer
     * @returns {Observable<DataEntity>} L'observable de création de l'entité
     */
    duplicateEntity(entity: DataEntity): Observable<DataEntity>;
    registerEntitySubject(entityId: number, subject: ReplaySubject<DataEntity>): void;
    /**
     * Enregistre un entité en cache
     * @param entity L'entité à mettre en cache
     * @param entityObservable L'observable de cette entité
     * @param observer L'observer de cette entité
     */
    registerEntity(entity: DataEntity, entityObservable: ReplaySubject<DataEntity>): void;
    /**
     * Supprime l'entité du cache
     * @param entity L'entité à supprimer du cache
     */
    unregisterEntity(entity: DataEntity): void;
    registerEntityCollectionSubject(collectionType: string, subject: ReplaySubject<DataEntityCollection>): void;
    /**
     * Enregistre une collection d'entités dans le cache
     * @param collection La collection à enregistrer dans le cache
     * @param entityCollectionObservable L'observable de la collection
     */
    registerEntityCollection(collection: DataEntityCollection, entityCollectionObservable: ReplaySubject<DataEntityCollection>): void;
}