import { HttpClient } from "@angular/common/http";
import { IServiceOptions, IServiceMethods, IServiceDataLoader } from "./interfaces/utils.interface";
import { ResponseData, RequestSetting } from "./helpers/response";
import { ModelState, DeletionMode, CrudAction, DataType, PushMode, EntityState, SaveMode } from "./helpers/enums";
import { Injector, EventEmitter } from "@angular/core";
import { CrudService } from "./components/crud/crud.service";
import { BlockerManager } from "./helpers/modal-option";
import { ResponseSetting } from "./helpers/response";
import { Filter } from "./helpers/filtrable";
import { ServerMethods } from "./helpers/server-methods";
import { MessageService } from "primeng/api";
import { Observable } from "rxjs/internal/Observable";
import { Subscription } from "rxjs/internal/Subscription";
import { ConfigService } from "./services/config.service";
import { ComponentManager } from "./component-manager";
export declare class BaseObject {
}
export declare class DataService {
    readonly GET: string;
    readonly POST: string;
    readonly PUT: string;
    readonly DELETE: string;
    readonly PATCH: string;
    onError: EventEmitter<string>;
    onRequest: EventEmitter<string>;
    onResponse: EventEmitter<string>;
    injector: Injector;
    http: HttpClient;
    constructor();
    httpGet(url: string, params?: any, callback?: Function): Observable<ResponseData>;
    httpPost(url: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    httpPut(url: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    httpPatch(url: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    httpDelete(url: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    httpVerb(verb: string, url: string, body?: any, callback?: any | Function): Observable<ResponseData>;
}
export declare class ServiceBase extends DataService {
    resourceUrl?: string;
    private _waiting;
    private _subscriptions;
    protected canMakeRequestToServer: boolean;
    busy: boolean;
    configService: ConfigService;
    toastr: MessageService;
    crudService: CrudService;
    blocker: BlockerManager;
    waiting: boolean;
    readonly urlResource: string;
    readonly url: string;
    constructor(resourceUrl?: string);
    getMethod(controllerMethod: string, params?: any, callback?: Function): Observable<ResponseData>;
    postMethod(controllerMethod: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    putMethod(controllerMethod: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    patchMethod(controllerMethod: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    deleteMethod(controllerMethod: string, body?: any, callback?: any | Function): Observable<ResponseData>;
    Error(error: string): void;
    Request(): void;
    Response(method: string): void;
    hasSubscriptions(): boolean;
    subscribe(): void;
    unsubscribe(): void;
    validateSubscriptions(): void;
}
export declare class ServiceManager<T extends BaseObject> extends ServiceBase implements IServiceDataLoader<T> {
    private _state;
    private _defaultModelValue;
    private _prior;
    private _settingCanBeLoaded;
    private _saveMode;
    readonly MODEL_STATE: typeof ModelState;
    readonly CRUD_ACTION: typeof CrudAction;
    loadEmitter: EventEmitter<{}>;
    addEmitter: EventEmitter<{}>;
    addedEmitter: EventEmitter<{}>;
    editEmitter: EventEmitter<{}>;
    editedEmitter: EventEmitter<{}>;
    deleteEmitter: EventEmitter<{}>;
    deletedEmitter: EventEmitter<{}>;
    stateChangeEmitter: EventEmitter<{}>;
    cancelEmitter: EventEmitter<{}>;
    requeryCompleteEmitter: EventEmitter<{}>;
    model: T;
    current: T;
    cacheData: any;
    identityPropertyName: string;
    resourceName: string;
    changeTracker: SingleChangeTracker;
    componentManager: ComponentManager<T>;
    data: T[];
    rowsPerPage: number[];
    saveAndNew: boolean;
    /**
     *Especifica el lugar desde donde es invocado el ServiceManager y se ejecuta en el siguiente orden:
      manager -> list: al hacer un refresh en el explorador desde el ListManager
      manager -> form: al hacer un refresh en el explorador desde el FormManager
     *
     * @type {('manager' | 'list' | 'form')}
     * @memberof ServiceManager
     */
    callerComponent: CallerComponent;
    saveAndKeep: boolean;
    requeryOnEdit: boolean;
    loadingOnAdd: boolean;
    loadingOnEdit: boolean;
    loadingOnDelete: boolean;
    loadingOnRequery: boolean;
    loadingOnGet: boolean;
    skipLoadingOnGetOnce: boolean;
    identityPropertyType: DataType;
    deletionMode: DeletionMode;
    pushMode: PushMode;
    requestSetting: RequestSetting;
    responseSetting: ResponseSetting;
    serverMethods: ServerMethods;
    routingUrl: string;
    Filter: Filter;
    setOptions(options: IServiceOptions): void;
    identityValue: number | string;
    readonly state: ModelState;
    constructor(resourceUrl: string | typeof BaseObject, cls?: typeof BaseObject);
    getDefaultModel(): T;
    getSubscription(requestSetting: RequestSetting, callback?: Function): Observable<ResponseData>;
    deleteSubscription(callback?: Function): Observable<ResponseData>;
    addSubscription(callback?: Function): Observable<ResponseData>;
    editSubscription(callback?: Function): Observable<ResponseData>;
    getSettingSubscription(requestSetting?: RequestSetting, callback?: Function): Observable<ResponseData>;
    requerySubscription(identity: any, callback?: Function): Observable<ResponseData>;
    setModalFilter(): void;
    load(requestSetting?: RequestSetting): void;
    add(model?: T): void;
    edit(model?: T): void;
    delete(model: T): void;
    erase(model: T): void;
    localPost(model?: ResponseData | T): void;
    post(): void;
    cancel(): void;
    refresh(skipLoadingOnGetOnce?: boolean): void;
    setCurrent(currentModel: T, callback?: Function): void;
    updateCurrent(currentModel: T): void;
    stateChange(state: ModelState, curState?: ModelState): void;
    protected _push(current: T): void;
    trackByFn(index: number, model: T): any;
}
export declare class ServiceSubscriber {
    private _suscriptions;
    private _dataService;
    private _methodsHost;
    private _callback;
    constructor(serviceManager: ServiceManager<any>, methodsHost?: IServiceMethods);
    callBack(callback: Function): void;
    private _callbackArgs;
    addSubscription(subscription: Subscription): void;
    subscribe(): void;
    unsubscribe(): void;
}
export declare class SingleModelEntry {
    private _oldMark;
    private _changeTracker;
    Model: any;
    constructor(model: any, changeTracker?: SingleChangeTracker);
    state: EntityState;
    attach(mode?: SaveMode): void;
    saveChanges(mode?: SaveMode): void;
    reset(): void;
    canBeHardDeleted(): boolean;
    markAsModified(): void;
    markAsDeleted(): void;
    markAsAdded(): void;
    hasChanges(): boolean;
    touchable(): boolean;
    readonly identityValue: number;
}
export declare class SingleChangeTracker {
    identityPropertyName: string;
    constructor(identityPropertyName: string);
    entry(model: any): SingleModelEntry;
}
export declare class CallerComponent {
    host: "manager" | "list" | "form";
    state: "initializing" | "destroying";
    resetState(): void;
}