import NovaObject from "../base/NovaObject";
import JSONDataReader from "./JSONDataReader";
import { Model, DataSourceSchema } from "./Schema";
import { IView } from "./View";
export declare const CREATE = "create";
export declare const READ = "read";
export declare const UPDATE = "update";
export declare const DESTROY = "destroy";
export declare const REQUESTIDLE = "requestIdle";
export declare const REQUESTSTART = "requestStart";
export declare const PROGRESS = "progress";
export declare const REQUESTEND = "requestEnd";
export declare const ERROR = "error";
export declare const SYNC = "sync";
export declare const CHANGE = "change";
export declare type HTTPMethod = 'POST' | 'GET' | 'PUT' | 'DELETE' | 'post' | 'get' | 'put' | 'delete';
export declare type HTTPDataType = 'JSON' | 'json';
export declare type HTTPContentType = 'application/x-www-form-urlencoded' | 'application/json';
export declare type TransportMethod = string | {
    url: string | Function;
    dataType?: HTTPDataType;
    type?: HTTPMethod;
    contentType?: HTTPContentType;
    data?: {
        [key: string]: any;
    };
} | ((options?: any) => any);
export interface ITransport {
    read: TransportMethod;
    create?: TransportMethod;
    update?: TransportMethod;
    destroy?: TransportMethod;
    submit?: (data: {
        created;
        updated;
        destroyed;
    }) => Promise<Array<{
        response?: any;
        type: 'create' | 'update' | 'destroy';
    }>>;
    parameterMap?: (data: any, type: 'read' | 'create' | 'update' | 'destroy') => any;
}
export default class DataSource<T> extends NovaObject {
    private _map;
    private _prefetch;
    private _loadMore;
    private _pageSize;
    private _total;
    private _sort;
    private _filter;
    private _bindVars;
    private _group;
    private _aggregate;
    private _errorInfo;
    protected _data: any;
    private _destroyed;
    private _pristineData;
    private _pristineTotal;
    private _transport;
    private _online;
    private _requestInProgress;
    private _pending;
    protected reader: JSONDataReader;
    protected options: DataSourceOptions;
    private _page;
    private _skip;
    private _take;
    private _currentRangeStart;
    private _fetchingStatus;
    private _observeList;
    private _view;
    private _aggregateResult;
    private _ranges;
    initializeState: boolean;
    constructor(options?: DataSourceOptions);
    dispose(): any;
    protected defaultOptions(): any;
    readonly sort: any[];
    setSort(value: any): Promise<any>;
    readonly filter: DataFilter;
    setFilter(value: DataFilter | DataFilter[]): Promise<any>;
    readonly bindVars: {
        [p: string]: any;
    };
    readonly group: any[];
    setGroup(value: Object | Array<Object>, local?: boolean): Promise<any>;
    readonly aggregate: Array<Object>;
    setAggregate(value: Array<Object>): Promise<any>;
    readonly aggregates: any;
    _emptyAggregates(aggregates: any): {};
    _wrapInEmptyGroup(model: any): any;
    readonly loadMore: boolean;
    getPrimaryId(model: any): any;
    getIdentifer(data: any): any;
    get(id: number | string): T;
    getByUid(uid: string): T;
    readonly hasChanges: boolean;
    add(model?: any): T;
    remove(model: any): T;
    pushCreate(items: any, index?: number): void;
    pushUpdate(items: any): void;
    pushDestroy(items: any): void;
    protected _removeItems(items: any): Array<T>;
    insert(index: number, model?: any): T;
    batchInsert(index: number, models: any[]): T[];
    cancelChanges(model?: any): void;
    readonly isDirty: boolean;
    sync(): Promise<any>;
    readonly transport: TransportClass;
    readonly parent: any;
    readonly view: IView;
    setView(data?: any[]): void;
    protected _observeView(data?: any[], view?: any): IView;
    flatView(): any[];
    private _sendSubmit(created, updated, destroyed);
    private _submit(promises, data);
    private _send(method, data);
    private _promise(data, models, type);
    private _accept(result);
    private _updatePristineForModel(model, values);
    private _removePristineForModel(model);
    private _executeOnPristineForModel(model, callback);
    private _change(e?);
    private _storeData(updatePristine?);
    readonly created: Array<T>;
    readonly updated: Array<T>;
    readonly destroyed: Array<T>;
    private readonly _created;
    private readonly _updated;
    private _eachItem(data, callback);
    private _updateTotalForAction(action, items);
    private _cancelModel(model);
    private _pristineForModel(model);
    private _eachPristineItem(callback);
    protected _createNewModel(model: any): any;
    readonly errorInfo: ErrorInfo;
    readonly fetchingStatus: string;
    data: Array<T>;
    readonly total: number;
    private _mergeState(options);
    refresh(options?: any): Promise<any>;
    query(options?: any): Promise<any>;
    read(data?: any): Promise<any>;
    _readAggregates(data: any): any;
    success(data: any, requestParams?: any): void;
    _addRange(data: any): void;
    _flatData(data?: any, skip?: any): any;
    _isServerGrouped(): boolean;
    error(xhr: any, status: any, errorThrown: any): void;
    protected _shouldReplaceAllData(): boolean;
    private _handlerData(data);
    protected _readData(data: any): any;
    protected _observeNewObject(obj: any): void;
    protected _observe(data: any): any;
    _calculateAggregates(data: any, options: any): {};
    protected _process(data: any, e?: any): void;
    protected _queryProcess(data: any, options?: any, localSorting?: boolean): {
        total: any;
        data: any[];
    };
    private _handleCustomErrors(response);
    private _params(data);
    protected _queueRequest(options: any, callback: any): void;
    private _dequeueRequest();
    page: number;
    readonly take: number;
    readonly skip: number;
    pageSize: number;
    calculatePage(): number;
    readonly totalPages: number;
    readonly hasMore: boolean;
    fetch(callback?: any): any;
    private _query(options?);
    firstPage(options?: any): Promise<any>;
    prevPage(options?: any): Promise<any>;
    nextPage(options?: any): Promise<any>;
    lastPage(options?: any): Promise<any>;
    toPage(page: number, options?: any): Promise<any>;
}
export declare class Query {
    private readonly localSorting;
    private _data;
    constructor(data: any, localSorting?: boolean);
    readonly data: Array<any>;
    toArray(): Array<any>;
    range(index: any, count: any): Query;
    skip(count: any): Query;
    take(count: any): Query;
    select(selector: any): Query;
    order(selector: any, dir: any): Query;
    orderBy(selector: any): Query;
    orderByDescending(selector: any): Query;
    sort(field: any, dir?: any, comparer?: any): Query;
    filter(expressions: any): Query;
    group(descriptors: any, allData: any): Query;
    groupBy(descriptor: any): Query;
    _sortForGrouping(field: any, dir: any): any[];
    aggregate(aggregates?: any): {};
    static process(data: any, options?: any, localSorting?: boolean): {
        total: any;
        data: any[];
    };
    static filterExpr(expression: any): {
        expression: string;
        fields: Array<Function>;
        operators: Array<Function>;
    };
}
export interface SortOption {
    field: string;
    dir?: string;
}
export interface IOfflineStorage {
    setItem: (item) => void;
    getItem: () => {
        [key: string]: any;
    };
}
export interface DataSourceEvent {
    sender?: DataSource<any>;
}
export interface DataSourceItemOrGroup {
}
export interface DataFilter {
    field?: string;
    filters?: DataFilter[];
    logic?: string;
    operator?: string;
    value?: any;
}
export interface DataSourceGroupItem {
    field?: string;
    dir?: string;
    aggregates?: DataSourceGroupItemAggregate[];
}
export interface DataSourceGroupItemAggregate {
    field?: string;
    aggregate?: string;
}
export interface DataSort {
    field?: string;
    dir?: string;
}
export interface DataSourceChangeEvent extends DataSourceEvent {
    field?: string;
    value?: Model;
    action?: string;
    index?: number;
    items?: DataSourceItemOrGroup[];
    node?: any;
}
export interface DataSourceOptions {
    data?: any;
    autoSync?: boolean;
    readonly?: boolean;
    batch?: boolean;
    local?: boolean;
    serverSorting?: boolean;
    serverFiltering?: boolean;
    serverGrouping?: boolean;
    serverAggregates?: boolean;
    serverPaging?: boolean;
    offlineStorage?: any;
    schema?: DataSourceSchema;
    page?: number;
    pageSize?: number;
    filter?: DataFilter | DataFilter[];
    group?: DataSourceGroupItem[];
    aggregate?: Array<Object>;
    total?: number;
    sort?: any;
    bindVars?: {
        [key: string]: any;
    };
    loadMore?: boolean;
    transport?: ITransport;
    change?(e: DataSourceChangeEvent): void;
    sync?(e: DataSourceEvent): void;
    error?(e: DataSourceErrorEvent): void;
    requestStart?(e: DataSourceRequestStartEvent): void;
    requestEnd?(e: DataSourceRequestEndEvent): void;
}
export interface DataSourceErrorEvent extends DataSourceEvent {
    xhr: any;
    status: string;
    errorThrown: any;
    errors?: any;
}
export interface DataSourceRequestStartEvent extends DataSourceEvent {
    type?: string;
}
export interface DataSourceRequestEndEvent extends DataSourceEvent {
    response?: any;
    type?: string;
}
export interface ErrorInfo {
    xhr: any;
    status: number | string;
    errorThrown: any;
    errors?: any;
}
export interface TransportClass {
    read: (options) => Promise<any>;
    create?: (data) => Promise<any>;
    update?: (data) => Promise<any>;
    destroy?: (data) => Promise<any>;
    submit?: (data: {
        created;
        updated;
        destroyed;
    }) => Promise<Array<{
        response?: any;
        type: 'create' | 'update' | 'destroy';
    }>>;
}
export declare const operatorMap: {
    "==": string;
    equals: string;
    isequalto: string;
    equalto: string;
    equal: string;
    "!=": string;
    ne: string;
    notequals: string;
    isnotequalto: string;
    notequalto: string;
    notequal: string;
    "<": string;
    islessthan: string;
    lessthan: string;
    less: string;
    "<=": string;
    le: string;
    islessthanorequalto: string;
    lessthanequal: string;
    ">": string;
    isgreaterthan: string;
    greaterthan: string;
    greater: string;
    ">=": string;
    isgreaterthanorequalto: string;
    greaterthanequal: string;
    ge: string;
    substringof: string;
    notsubstringof: string;
    isnull: string;
    isempty: string;
    isnotempty: string;
};