import { ComponentStore } from '@metad/store';
import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
import { PeriodFunctions, PresentationVariant, SelectionVariant } from '../annotations';
import { DataSettings } from '../data-settings';
import { DataSourceOptions } from '../data-source';
import { DSCoreService } from '../ds-core.service';
import { EntityService } from '../entity';
import { EntityType, Property, QueryReturn } from '../models';
import { Annotation, AnnotationTerm, Dimension, Measure, QueryOptions } from '../types';
export interface EntityBusinessState {
    dataSettings: DataSettings;
    selectionVariant?: SelectionVariant;
    presentationVariant?: PresentationVariant;
    dataSourceOptions: DataSourceOptions;
}
export declare class EntityBusinessService<T, State extends EntityBusinessState = EntityBusinessState> extends ComponentStore<State> {
    dsCoreService: DSCoreService;
    protected __id__: string;
    get dataSettings(): DataSettings;
    set dataSettings(value: DataSettings);
    readonly dataSettings$: Observable<DataSettings>;
    readonly _dataSource$: Observable<string>;
    readonly entitySet$: Observable<string>;
    get selectionVariant(): SelectionVariant;
    set selectionVariant(value: SelectionVariant);
    get presentationVariant(): PresentationVariant;
    set presentationVariant(value: PresentationVariant);
    readonly presentationVariant$: Observable<PresentationVariant>;
    get slicers(): (string | import("../types").ISlicer | import("../types").IFilter | import("../types").IAdvancedFilter)[];
    set slicers(value: (string | import("../types").ISlicer | import("../types").IFilter | import("../types").IAdvancedFilter)[]);
    private _initialise$;
    readonly initialise$: Observable<boolean>;
    loading$: BehaviorSubject<boolean>;
    protected result$: BehaviorSubject<QueryReturn<T>>;
    readonly dataSource$: Observable<import("../data-source").DataSource>;
    get entityService(): EntityService<T>;
    protected entityService$: BehaviorSubject<EntityService<T>>;
    internalError$: ReplaySubject<any>;
    protected refresh$: ReplaySubject<boolean | void>;
    /**
     * @deprecated use `getEntityType` or `selectEntityType` method
     */
    entityType: EntityType;
    constructor(dsCoreService: DSCoreService);
    /**
     * @experiment Use async await as the asynchronous processing method for getXXX method;
     *   use Observable as the asynchronous processing method for selectXXX method;
     *
     * @returns
     */
    getEntityType(): Promise<EntityType>;
    /**
     * @experiment Use async await as the asynchronous processing method of getXXX method
     *
     * @returns
     */
    getProperty(name: Dimension | Measure | string): Promise<Property>;
    selectEntityType(): Observable<EntityType>;
    query(options?: QueryOptions): Observable<QueryReturn<T>>;
    /**
     * If you change the query conditions and logic first, you can override this method in the subclass
     *
     * @param options `QueryOptions`
     */
    selectQuery(options?: QueryOptions): Observable<QueryReturn<T>>;
    refresh(force?: boolean): void;
    selectResult<R = QueryReturn<T>>(): Observable<R>;
    calculateFilters(queryOptions?: QueryOptions): QueryOptions<any>;
    getAnnotation<AT extends Annotation>(term: AnnotationTerm, qualifier?: string): Observable<AT>;
    getCalculatedMember(measure: string, type: PeriodFunctions, calendar?: string): Property;
    getIndicator(idOrCode: string): import("../models").Indicator;
    selectIndicator(idOrCode: string): Observable<import("../models").Indicator>;
}