import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
import { Agent } from './agent';
import { EntityService } from './entity';
import { CalculatedProperty, Catalog, Cube, Entity, EntitySet, EntityType, IDimensionMember, Indicator, MDCube, Schema, SemanticModel } from './models';
import { Dimension } from './types';
import { Type } from './utils/index';
export type DataSourceFactory = () => Promise<Type<DataSource>>;
export declare enum AuthenticationMethod {
    none = "none",
    basic = "basic",
    saml = "saml",
    independent = "independent"
}
/**
 * Property settings related to data source type
 */
export interface DataSourceSettings {
    dataSourceId?: string;
    database?: string;
    language?: string;
    ignoreUnknownProperty?: boolean;
}
export interface DataSources {
    [name: string]: DataSourceOptions;
}
/**
 * Data source configuration items
 * Actually corresponds to a semantic model rather than a data source
 *
 * @TODO needs to be redefined using the CSDL concept
 * * entityTypes configures multiple entities under this data source
 * * entityType configures the type field of each entity
 * * annotations configures the annotations of each entity
 */
export interface DataSourceOptions extends SemanticModel {
    settings?: DataSourceSettings;
    authMethod?: string;
    useLocalAgent?: boolean;
    /**
     * Default: client
     * - client: in client send query options to server
     * - server: query xmla
     */
    mode?: 'client' | 'server';
    /**
     * Runtime calculated measures, indexed by cube name
     */
    calculatedMeasures?: Record<string, CalculatedProperty[]>;
    /**
     * Is draft semantic model
     */
    isDraft?: boolean;
    /**
     * Is use indicators draft
     */
    isIndicatorsDraft?: boolean;
    /**
     * Key-value pairs of parameters for cube
     */
    parameters?: Record<string, Record<string, any>>;
}
/**
 * Abstract interface of data source
 * - options configuration items
 * - createEntityService creates entityService
 * - getAnnotation gets annotation
 */
export interface DataSource {
    id: string;
    options: DataSourceOptions;
    agent: Agent;
    refresh(): void;
    /**
     * Update options of DataSource
     */
    updateOptions(fn: (options: DataSourceOptions) => DataSourceOptions): void;
    /**
     * @deprecated use discoverDBCatalogs
     */
    getCatalogs(): Observable<Array<Catalog>>;
    /**
     * Discover catalogs or schemas from DataSource's Database: The data service catalog is used to distinguish different data entity categories, such as Catalog of ODataService, CATALOG_NAME of XMLA, etc.
     */
    discoverDBCatalogs(options?: {
        throwError?: boolean;
    }): Observable<Array<DBCatalog>>;
    /**
     * Discover tables from DataSource's Database
     */
    discoverDBTables(refresh?: boolean): Observable<Array<DBTable>>;
    /**
     * Discover cubes from api or schema defination of DataSource
     */
    discoverMDCubes(refresh?: boolean): Observable<Array<MDCube>>;
    /**
     * Discover members of dimension
     *
     * @param entity
     * @param dimension
     */
    discoverMDMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    /**
     * @deprecated use selectEntitySets
     */
    getEntitySets(refresh?: boolean): Observable<Array<EntitySet>>;
    /**
     * Observe entity sets from DataSource
     *
     * @param refresh Force refresh cache in browser
     */
    selectEntitySets(refresh?: boolean): Observable<Array<EntitySet>>;
    /**
     * @deprecated The EntityType interface should not be exposed directly at runtime, use the selectEntitySet method
     */
    getEntityType(entity: string): Observable<EntityType | Error>;
    /**
     * @deprecated use selectMembers
     */
    getMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    /**
     * Observe members of dimension in entity (cube) from DataSource
     *
     * @param entity Cube name
     * @param dimension Dimension, include name and hierarchy
     */
    selectMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    /**
     * Creates a corresponding entityService based on the specified entitySet name
     */
    createEntityService<T>(entity: string): EntityService<T>;
    /**
     * Observe options
     */
    selectOptions(): Observable<DataSourceOptions>;
    /**
     * Observe runtime schema
     */
    selectSchema(): Observable<Schema>;
    /**
     * Setting a custom Schema
     *
     * @param schema EDMSchema
     */
    setSchema(schema: Schema): void;
    /**
     * Update the schema
     *
     * @param fn
     */
    updateSchema(fn: (schema: Schema) => Schema): void;
    /**
     * Update a single cube definition
     *
     * @param cube
     */
    updateCube(cube: Cube): void;
    /**
     * Update the value of parameters in cube
     *
     * @param cube Cube name
     * @param fn Update function
     */
    updateParameters(cube: string, fn: (state: Record<string, any>) => Record<string, any>): void;
    /**
     * Insert or update a indicator by `code`
     */
    upsertIndicator(indicator: Indicator): void;
    /**
     * Observe to Entity type definition changes, merge runtime and user enhancements
     *
     * @param entity
     */
    selectEntitySet(entity: string): Observable<EntitySet | Error>;
    /**
     * Set up EntityType individually
     *
     * @param entityType EntityType
     */
    setEntityType(entityType: EntityType): void;
    /**
     * Observe type defination of entity (or Error) (combine runtime type and custom types)
     *
     * @param entity
     */
    selectEntityType(entity: string): Observable<EntityType | Error>;
    /**
     * Observe indicators of entity
     *
     * @param entitySet Cube name
     */
    selectIndicators(entity: string): Observable<Array<Indicator>>;
    /**
     * Observe an indicator by code from model
     */
    selectIndicator(cube: string, code: string): Observable<Indicator>;
    /**
     * Get an indicator by id from entity
     *
     * @param idOrCode Indicator `ID` or `Code`
     * @param cube Cube name
     */
    getIndicator(idOrCode: string, cube?: string): Indicator;
    /**
     * Create DB Table
     *
     * @param name
     * @param columns
     * @param data
     */
    createEntity(name: string, columns: any, data?: any): Observable<string>;
    /**
     * Drop DB Table
     *
     * @param name
     */
    dropEntity(name: string): Promise<void>;
    /**
     * Use statement query
     *
     * @param statement
     */
    query(options: {
        statement: string;
        forceRefresh?: boolean;
        timeout?: number;
    }): Observable<any>;
    /**
     * Clear the browser cache
     *
     * @deprecated
     */
    clearCache(): Promise<void>;
    /** Completes all relevant Observable streams. */
    onDestroy(): void;
}
/**
 * Implement common functions of the data source model, including obtaining metadata, executing some operations and queries unrelated to specific model entities, creating entity services, etc.
 *
 */
export declare abstract class AbstractDataSource<T extends DataSourceOptions> implements DataSource {
    agent: Agent;
    id: string;
    protected readonly destroySubject$: ReplaySubject<void>;
    readonly destroy$: Observable<void>;
    private options$;
    get options(): T;
    readonly calculatedMeasures$: Observable<Record<string, CalculatedProperty[]>>;
    protected _entitySets: {};
    constructor(options: T, agent: Agent);
    readonly refresh$: BehaviorSubject<void>;
    abstract discoverDBCatalogs(): Observable<Array<DBCatalog>>;
    abstract discoverDBTables(): Observable<Array<DBTable>>;
    abstract discoverMDCubes(refresh?: boolean): Observable<Array<EntitySet>>;
    abstract discoverMDMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    abstract createEntityService<T>(entity: string): EntityService<T>;
    abstract getEntitySets(refresh?: boolean): Observable<Array<EntitySet>>;
    abstract selectEntitySets(refresh?: boolean): Observable<Array<EntitySet>>;
    abstract getEntityType(entity: string): Observable<EntityType | Error>;
    abstract getCatalogs(): Observable<Array<Catalog>>;
    abstract getMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    abstract selectMembers(entity: string, dimension: Dimension): Observable<IDimensionMember[]>;
    abstract createEntity(name: string, columns: any[], data?: any[]): Observable<string>;
    abstract dropEntity(name: string): Promise<void>;
    abstract query(options: {
        statement: string;
        forceRefresh?: boolean;
        timeout?: number;
    }): Observable<any>;
    refresh(): void;
    updateOptions(fn: (options: T) => T): void;
    setSchema(schema: Schema): void;
    updateSchema(fn: (schema: Schema) => Schema): void;
    updateCube(cube: Cube): void;
    updateParameters(cube: string, fn: (state: Record<string, any>) => Record<string, any>): void;
    upsertIndicator(indicator: Indicator): void;
    selectOptions(): Observable<DataSourceOptions>;
    selectSchema(): Observable<Schema>;
    setEntityType(entityType: EntityType): void;
    /**
     * This is only responsible for the EntitySet setting during merge runtime, not for Cube type compilation,
     *  which is done when getEntityType gets the original type.
     *
     * @param entity
     * @returns
     */
    selectEntitySet(entity: string): Observable<EntitySet | Error>;
    selectEntityType(entity: string): Observable<EntityType | Error>;
    selectIndicators(entity: string): Observable<Indicator[]>;
    selectIndicator(cube: string, code: string): Observable<Indicator>;
    getIndicator(id: string, entity?: string): Indicator;
    selectCalculatedMeasures(cube: string): Observable<CalculatedProperty[]>;
    clearCache(key?: string): Promise<void>;
    onDestroy(): void;
}
/**
 * Compile indicator to measures
 *
 * @param indicator
 * @returns
 */
export declare function mapIndicatorToMeasures(indicator: Indicator): any[];
export interface DBCatalog {
    name: string;
    label: string;
}
export interface DBTable extends Entity {
    catalog?: string;
    name: string;
    /**
     * @deprecated use caption
     */
    label?: string;
    columns?: DBColumn[];
}
export interface DBColumn {
    name: string;
    label?: string;
    type: string;
    dbType?: string;
    nullable?: boolean;
    position?: number;
    /**
     * 应该等同于 label
     */
    comment?: string;
}