import { Observable, Subject, ReplaySubject } from 'rxjs';
import { ModelSchema } from 'octopus-model';
import * as i0 from '@angular/core';
import { ModuleWithProviders } from '@angular/core';

declare enum OrderDirection {
    ASC = "asc",
    DESC = "desc"
}

interface OrderCriteria {
    field: string;
    direction: OrderDirection;
}

interface CollectionOptionsInterface {
    filter?: {
        [key: string]: any;
    };
    page?: number;
    offset?: number;
    range?: number;
    urlExtension?: string;
    orderOptions?: OrderCriteria[];
}

/**
 * Local storage interface configuration
 */
interface LocalStorageConfiguration {
    /**
     * Optional prefix for indexing in localstorage
     */
    prefix?: string;
}

/**
 * Entity raw data
 */
type EntityDataSet<T = {
    [key: string]: any;
}> = T & {
    id?: number;
};
/**
 * Collection raw data
 */
interface CollectionDataSet<T extends {
    [key: string]: any;
}> {
    /**
     * Entities data, indexed by id
     */
    [key: number]: EntityDataSet<T>;
}
/**
 * Filter object
 */
interface FilterData {
    /**
     * Filter properties, indexed by string key name
     */
    [key: string]: any;
}

/**
 * Base external interface
 */
declare abstract class ExternalInterface<T extends {
    [key: string]: any;
}> {
    get authenticated(): Observable<EntityDataSet<T>>;
    unexpectedLogoutSubject: Subject<void>;
    /**
     * if true, the save method will only send the modified properties to the service
     */
    useDiff: boolean;
    retryTimeout: number;
    maxRetry: number;
    /**
     * Load an entity from the service
     * @param type Name of the endpoint
     * @param id Id of the entity
     * @param errorHandler Function used to handle errors
     * @returns A set of data, or an observable
     */
    loadEntity(type: string, id: number | string, errorHandler?: Function): EntityDataSet<T> | Observable<EntityDataSet<T>>;
    /**
     * Load an entity collection from the service
     * @param type Name of the endpoint
     * @param filter Collection filter object
     * @param errorHandler Function used to handle errors
     * @returns A collection set of data, or an observable
     */
    loadCollection(type: string, filter: FilterData, errorHandler?: Function): CollectionDataSet<T> | Observable<CollectionDataSet<T>>;
    /**
     *
     */
    clear(): void;
    paginatedLoadCollection(type: string, options: CollectionOptionsInterface, paginator: CollectionPaginator<T>, errorHandler?: Function): CollectionDataSet<T> | Observable<CollectionDataSet<T>>;
    /**
     * Create an entity on the service
     * @param type Endpoint name
     * @param data Base data used to create the entity
     * @param errorHandler Function used to handle errors
     * @returns A set of data, or an observable
     */
    createEntity(type: string, data: EntityDataSet<any>, errorHandler?: Function): EntityDataSet<T> | Observable<EntityDataSet<T>>;
    /**
     * Delete an entity from the service
     * @param type Name of the endpoint
     * @param id Id of the entity
     * @param errorHandler Function used to handle errors
     * @returns True if deletion success
     */
    deleteEntity(type: string, id: number | string, errorHandler?: Function): boolean | Observable<boolean>;
    /**
     * Save an entity on the service
     * @param data Data to Save
     * @param type Name of the endpoint
     * @param id Id of the entity
     * @param errorHandler Function used to handle errors
     * @returns The saved data
     */
    saveEntity(data: EntityDataSet<T>, type: string, id: number | string, errorHandler?: Function): EntityDataSet<T> | Observable<EntityDataSet<T>>;
    /**
     * Authenticating to the service
     * @param login User login
     * @param password User password
     * @param errorHandler Function used to handle errors
     */
    authenticate(login: string, password: string, errorHandler?: Function): Observable<EntityDataSet<T>>;
    logout(): Observable<boolean>;
    /**
     * Release an endpoint if not useful anymore
     * @param type Name of the endpoint
     */
    release(type: string): void;
    /**
     * Sends an error message
     * @param code Error code
     * @param originalMessage Error original text message
     * @param errorHandler Error handler Function
     */
    sendError(code: number, originalMessage: string, errorHandler: Function, data?: Object): void;
}

interface HttpEndpointConfiguration {
    apiUrl?: string;
}

/**
 * Individual endpoint config
 */
interface EndpointConfig {
    /**
     * Service used by this endpoint
     */
    type: string;
    /**
     * Model structure associated to this endpoint
     */
    structure?: ModelSchema;
    /**
     * Does the endpoint use the connector cache ?
     */
    cached?: boolean;
    /**
     *
     */
    useLanguage?: boolean;
    /**
     * List of data attributes keys excluded in save and create actions, used in some services
     */
    exclusions?: string[];
    /**
     * List of nested attributes: key is attributeName, value is endpoint name
     */
    nesting?: {
        [key: string]: string;
    };
    /**
     *
     */
    embeddings?: {
        [key: string]: string;
    };
    /**
     * Optional data
     */
    datas?: HttpEndpointConfiguration;
    /**
     * Is automatic refresh enabled
     */
    refreshEnabled?: boolean;
    /**
     * If true, no authentication data need on this endpoint
     */
    authenticationFree?: boolean;
}

/**
 * Http interface configuration
 */
interface HttpConfiguration {
    /**
     * Base url of the api
     */
    apiUrl: string | Function;
    /**
     * List of header which will be sent with the requests
     */
    headers?: {
        [key: string]: string;
    };
    /**
     *
     */
    useApiExtension?: boolean;
}

interface NodejsConfiguration {
    socketUrl: string;
    messagePrefix?: string;
    retrievePrefix?: string;
    connectionCommand?: string;
}

/**
 * Drupal8 interface configuration
 */
interface Drupal8Configuration {
    /**
     * Base url of the api
     */
    apiUrl: string | Function;
    /**
     * List of header which will be sent with the requests
     */
    headers?: {
        [key: string]: string;
    };
    clientId: string;
    clientSecret?: string;
    scope?: string;
}

interface CordovaLocalConfiguration {
}

/**
 * Connector main configuration
 */
interface DataConnectorConfig {
    /**
     * Interface used when no interface name specified for an endpoint
     */
    defaultInterface: string;
    language?: string | Observable<string>;
    /**
     * Delay before action retry
     */
    retryTimeout?: number;
    /**
     * Max attempts number
     */
    maxRetry?: number;
    /**
     * Base configurations for each service type
     */
    configuration: {
        [key: string]: HttpConfiguration | LocalStorageConfiguration | NodejsConfiguration | Drupal8Configuration | CordovaLocalConfiguration;
    };
    declarations?: {
        [key: string]: string;
    };
    /**
     * Individual endpoint configuration
     */
    map?: {
        [key: string]: string | EndpointConfig;
    };
    interfaces?: {
        [key: string]: ExternalInterface<any>;
    };
    globalCallback?: Function;
    liveRefreshService?: string;
}

/**
 * Data entity unit object
 */
declare class DataEntity<T extends {
    [key: string]: any;
} = any> {
    type: string;
    private connector;
    id: number | string;
    private embeddingsConf;
    /**
     * Entity attributes
     */
    attributes: T;
    /**
     * Nested entities
     */
    nesting: T;
    relationship: {
        [key: string]: DataEntity<any>;
    };
    /**
     * Reference object for diff
     */
    private attributesRef;
    /**
     *
     */
    private embeddings;
    /**
     * Create the data entity
     * @param type Type of the entity
     * @param data Entity data
     * @param connector Reference to the connector
     * @param id Entity id
     * @param embeddingsConf Embeddings configuration
     */
    constructor(type: string, data: EntityDataSet<{
        [key: string]: any;
    }>, connector?: DataConnector, id?: number | string, embeddingsConf?: {
        [key: string]: string;
    });
    /**
     * Set an attribute by key
     * @param key Key name
     * @param value New value
     */
    set<U = any>(key: keyof (T | U), value: any): void;
    /**
     * Get an attribute by key
     * @param key Key name
     * @returns Value
     */
    get<U extends keyof T>(key: U): T[U];
    get hasChanges(): boolean;
    getEmbed<U extends {
        [key: string]: any;
    } = any, V = DataEntity<U>>(name: string): V | V[];
    /**
     * Save the entity
     * @returns The observable associated to the entity in connector stores
     */
    save(forceReload?: boolean, dispatchBeforeResponse?: boolean): Observable<DataEntity<T>>;
    saveAction(forceReload?: boolean, dispatchBeforeResponse?: boolean): Observable<DataEntity<T>>;
    /**
     * Delete the entity
     * @returns True if deletion success
     */
    remove(): Observable<boolean>;
    /**
     * Copy the attributes to generate the new reference object (for diff)
     */
    private generateReferenceObject;
    /**
     * Get an attributes cloned object
     * @returns The cloned attributes object
     */
    getClone(): EntityDataSet<T>;
    /**
     * Return the diff (only updated properties since last save action)
     * @returns Diff object
     */
    getDiff(): EntityDataSet<T>;
}

/**
 * Data collection object
 */
declare class DataCollection<T extends {
    [key: string]: any;
} = any> {
    type: string;
    private connector;
    paginated: boolean;
    count: number;
    /**
     * Entities contained by the collection
     */
    entities: DataEntity<T>[];
    /**
     * Observables of entities contained by the collection
     */
    entitiesObservables: Observable<DataEntity<T>>[];
    /**
     * Creates the collection
     */
    constructor(type: string, data: CollectionDataSet<T> | EntityDataSet<T>[], connector?: DataConnector, structure?: ModelSchema, embeddings?: {
        [key: string]: string;
    });
    /**
     * Remove entity from collection
     * @param id Id of the entity to delete
     */
    deleteEntity(id: number | string): void;
    /**
     * Register entity in collection, if not already contained by the collection
     * @param entity Entity to register
     * @param entityObservable Entity observable to register
     */
    registerEntity(entity: DataEntity<T>, entityObservable: Observable<DataEntity<T>>): void;
}

declare class InterfaceError {
    code: number;
    message: string;
    originalMessage: string;
    data: Object;
    constructor(code?: number, message?: string, originalMessage?: string, data?: Object);
}

interface PaginatedCollection<T extends {
    [key: string]: any;
} = any> {
    collectionObservable: Observable<DataCollection<T>>;
    paginator: CollectionPaginator<T>;
}

/**
 * Data connector class
 */
declare class DataConnector {
    configuration: DataConnectorConfig;
    /**
     * Available interfaces
     * @type {{}} External interfaces, indexed by name
     */
    private interfaces;
    /**
     * Entities store
     * @type {{}} Entities stores, indexed by endpoint name
     */
    private entitiesLiveStore;
    /**
     * Collections store
     * @type {{}} Collections stores, indexed by endpoint name
     */
    private collectionsLiveStore;
    /**
     * Server push listeners
     * @type {{}} Listeners, indexed by endpoint name
     */
    private pushListeners;
    /**
     *
     */
    currentLanguage: string;
    /**
     * Built-in external interfaces
     */
    private builtInFactories;
    globalMessageSubject: ReplaySubject<InterfaceError>;
    /**
     * Delay before action retry
     */
    private retryTimeout;
    /**
     * Max attempts number
     */
    private maxRetry;
    /**
     * Create a dataConnector
     * @param configuration Data connector configuration
     */
    constructor(configuration: DataConnectorConfig);
    private sendMessage;
    getRetryTimeout(type: string): number;
    getMaxRetry(type: string): number;
    setLanguage(language: string): void;
    globalCallback(code: number): void;
    /**
     * Get data interface by endpoint name
     * @param type Endpoint name
     * @returns External interface
     */
    private getInterface;
    /**
     * Get endpoint configuration
     * @param type Endpoint name
     * @returns Type of the endpoint, or endpoint configuration object
     */
    getEndpointConfiguration(type: string): string | EndpointConfig;
    /**
     * Get model schema used by the endpoint
     * @param type Endpoint name
     * @returns The model schema
     */
    private getEndpointStructureModel;
    /**
     * Get nesting attributes types
     * @param type Endpoint name
     * @returns The nested attributes types
     */
    private getNesting;
    private getDatas;
    private getEmbeddings;
    /**
     * Is this endpoint using connector cache
     * @param type Name of the endpoint
     * @returns True if the endpoint use cache
     */
    private useCache;
    /**
     * Get optional keys excluded for saving entities in this endpoint
     * @param type Endpoint name
     * @returns A list of string keys
     */
    private getExclusions;
    /**
     * Get the observable associated to an entity from the store
     * @param type Endpoint name
     * @param id Id of the entity
     * @returns The observable associated to the entity
     */
    private getEntityObservableInStore;
    /**
     * Get the observable associated to the collection from the store
     * @param type Endpoint name
     * @param filter Filter object
     * @param useCache Store the result in cache or retrieve it from cache
     * @param createIfNotExisted Create the observable if not existed
     * @returns The observable associated to the collection
     */
    private getCollectionObservableInStore;
    /**
     * Get the observable associated to an entity from the store, if the store is undefined, create it
     * @param type Endpoint name
     * @param id Id of the entity
     * @param createObservable
     * @returns The observable associated to the entity
     */
    private getEntitySubject;
    /**
     * Register entity in the stores
     * @param type Endpoint name
     * @param id Id of the entity
     * @param entity Entity
     * @param entityObservable Observable to register
     * @returns The observable associated to the entity
     */
    registerEntity<T extends {
        [key: string]: any;
    }>(type: string, id: number | string, entity: DataEntity<T>, entityObservable: Observable<DataEntity<T>>): Observable<DataEntity<T>>;
    registerEntityByData<T extends {
        [key: string]: any;
    }>(type: string, id: number | string, entityData: EntityDataSet<T>): void;
    private registerCollectionEntities;
    private replaceCollectionEntities;
    /**
     * Associate an entity suject the the entity in the entity store
     * @param type Endpoint name
     * @param id Id of the entity
     * @param subject Subject to associate
     */
    private registerEntitySubject;
    /**
     * Get observable associated to the collection from the store. If store is undefined, create it
     * @param type Endpoint name
     * @param filter Filter object
     * @param useCache
     * @returns Observable associated to the collection
     */
    private getCollectionObservable;
    /**
     * Register the collection and collection entities in the store
     * @param type Endpoint name
     * @param filter Filter object
     * @param collection Collection to register
     * @param refresh
     * @returns The observable associated to the collection
     */
    private registerCollection;
    private paginatedRegisterCollection;
    /**
     * Authenticate to the service
     * @param serviceName Name of service on which we authenticate
     * @param login User login
     * @param password User password
     */
    authenticate<T extends {
        [key: string]: any;
    }>(serviceName: string, login: string, password: string): Observable<DataEntity<T>>;
    authenticated<T extends {
        [key: string]: any;
    }>(serviceName: string): Observable<DataEntity<T>>;
    logout(serviceName: string): Observable<boolean>;
    /**
     * Release endpoint if not used
     * @param type Endpoint name
     */
    release(type: string): void;
    clear(): void;
    /**
     * Listen for an endpoint to be notified when data is pushed from the backend
     * @param type Endpoint name
     * @returns DataEntity observable associated to this entity
     */
    listen<T extends {
        [key: string]: any;
    }>(type: string): Observable<DataEntity<any>>;
    /**
     * Load entity in specified endpoint
     * @param type Endpoint name
     * @param id Entity id
     * @returns DataEntity observable associated to this entity
     */
    loadEntity<T extends {
        [key: string]: any;
    }>(type: string, id: number | string): Observable<DataEntity<T>>;
    /**
     * Load many entities
     * @param type Endpoint name
     * @param ids Entities ids array
     * @returns The data entities
     */
    loadEntities<T extends {
        [key: string]: any;
    }>(type: string, ids: number[]): Observable<DataEntity<T>[]>;
    paginatedLoadCollection<T extends {
        [key: string]: any;
    }>(type: string, options: CollectionOptionsInterface): PaginatedCollection<T>;
    paginatedLoadCollectionExec<T extends {
        [key: string]: any;
    }>(type: string, filter: {
        [key: string]: any;
    }, paginator: CollectionPaginator<T>): PaginatedCollection<T>;
    /**
     * Load collection from specified endpoint
     * @param type Endpoint name
     * @param filter Filter object
     * @returns Observable associated to this collection
     */
    loadCollection<T extends {
        [key: string]: any;
    }>(type: string, filter?: FilterData): Observable<DataCollection<T>>;
    sendReloadNotification(type: string, data?: Object): void;
    /**
     * Save entity
     * @param entity Entity to save
     * @param forceReload whether to reload data if nothing is saved or not
     * @param dispatchBeforeResponse register entity before save happens
     * @returns Observable associated to the entity
     */
    saveEntity<T extends {
        [key: string]: any;
    }>(entity: DataEntity<T>, forceReload?: boolean, dispatchBeforeResponse?: boolean): Observable<DataEntity<T>>;
    /**
     * Create entity to the specified endpoint service
     * @param type Endpoint name
     * @param data Data used to create the entity
     * @returns The observable associated to this entity
     */
    createEntity<T extends {
        [key: string]: any;
    } = {
        [key: string]: any;
    }>(type: string, data?: any, sendNotification?: boolean): Observable<DataEntity<T>>;
    /**
     * Creates an entity on the front only (will be saved on the server later)
     * @param type Endpoint type
     * @param data Data used to create the entity
     * @returns The observable associated to this entity
     */
    createTemporaryEntity<T extends {
        [key: string]: any;
    }>(type: string, data?: EntityDataSet<T>): Observable<DataEntity<T>>;
    /**
     * Delete an entity
     * @param entity Entity to delete
     * @returns True if deletion success
     */
    deleteEntity<T extends {
        [key: string]: any;
    }>(entity: DataEntity<T>): Observable<boolean>;
    /**
     * Delete entity from store
     * @param entity Entity to delete
     */
    unregisterEntity<T extends {
        [key: string]: any;
    }>(entity: DataEntity<T>): void;
    unregisterEntityTypeAndId<T extends {
        [key: string]: any;
    }>(type: string, id: number | string): void;
    /**
     * Refresh entity (from refresh service)
     * @param type Endpoint name
     * @param id Entity id
     */
    refreshEntity<T extends {
        [key: string]: any;
    }>(type: string, id: number): void;
    /**
     * Refresh collection (from refresh service)
     * @param type Endpoint name
     * @param filter Collection filter object
     */
    refreshCollection(type: string, filter: FilterData): void;
    private objectMatchFilter;
    refreshCollectionWithData(type: string, data: Object): void;
    refreshAllCollectionsOfType(type: string): void;
    getUnexpectedLogoutSubject(serviceName: string): Subject<void>;
}

declare class CollectionPaginator<T extends {
    [key: string]: any;
} = any> {
    private connector;
    private type;
    private options;
    mfilter: {
        [key: string]: any;
    };
    private _page;
    private _offset;
    private _range;
    private _urlExtension;
    private _orderOptions;
    private _filter;
    count: number;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    constructor(connector: DataConnector, type: string, options: CollectionOptionsInterface, mfilter: {
        [key: string]: any;
    });
    get filter(): {
        [key: string]: any;
    };
    set filter(value: {
        [key: string]: any;
    });
    get page(): number;
    set page(value: number);
    get offset(): number;
    set offset(value: number);
    get range(): number;
    set range(value: number);
    get urlExtension(): string;
    set urlExtension(value: string);
    get orderOptions(): OrderCriteria[];
    set orderOptions(value: OrderCriteria[]);
    updateCount(count: number): Promise<void>;
    reload(): void;
}

declare class OctopusConnectModule {
    static forRoot(configuration: DataConnectorConfig): ModuleWithProviders<OctopusConnectModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OctopusConnectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OctopusConnectModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OctopusConnectModule>;
}

declare class ConfigurationProvider {
    configuration: DataConnectorConfig;
    constructor(configuration: DataConnectorConfig);
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationProvider>;
}

declare class OctopusConnectService extends DataConnector {
    configurationProvider: ConfigurationProvider;
    constructor(configurationProvider: ConfigurationProvider);
    static ɵfac: i0.ɵɵFactoryDeclaration<OctopusConnectService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OctopusConnectService>;
}

export { CollectionPaginator, DataCollection, DataConnector, DataEntity, ExternalInterface, InterfaceError, OctopusConnectModule, OctopusConnectService, OrderDirection };
export type { CollectionDataSet, CollectionOptionsInterface, DataConnectorConfig, EntityDataSet, FilterData, OrderCriteria, PaginatedCollection };