import { BpmsEngine } from '../BpmsEngine';
import { DataSourceRepository } from './DataSourceRepository';
import { QueryOptions, QueryResult, ScalarOptions, FilterExpression } from './Repository';
import { BpmsService } from '../BpmsService';
export interface DataSourceServiceOptions {
    name: string;
    datasourceRepository?: DataSourceRepository;
}
export interface DataSourceSchema<T> {
    name: string;
    find(fn: (item: T, index: number) => boolean): Promise<T[]>;
    list(): Promise<T[]>;
    create(data: T): Promise<T>;
    remove(data: T | string | number): Promise<boolean>;
    count(): Promise<number>;
}
export declare type DataSourceObjectSchema = DataSourceSchema<Record<string, any>>;
export interface DataSourceWebApiSchema<T> extends DataSourceSchema<T> {
    url?: string;
    params?: any;
    method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
}
export interface DataSourceRestApiSchema<T> extends DataSourceSchema<T> {
    url?: string;
    params?: any;
}
export interface DataSourceDefinition {
    sources: Array<DataSourceSchema<any>>;
}
export interface BpmsDataSource {
    id?: string;
    name: string;
    definition: DataSourceDefinition;
    createdAt?: Date;
}
export declare class DataSourceService<T extends BpmsDataSource = BpmsDataSource> implements BpmsService {
    private datasourceCache;
    private id;
    private name;
    private datasourceRepository;
    private options;
    private bpmsEngine;
    constructor(options?: DataSourceServiceOptions);
    constructor(bpmsEngine?: BpmsEngine, options?: DataSourceServiceOptions);
    get Id(): string;
    get Name(): string;
    get BpmsEngine(): BpmsEngine | undefined;
    static createEngine(options?: DataSourceServiceOptions): DataSourceService;
    static createEngine(bpmsEngine?: BpmsEngine, options?: DataSourceServiceOptions): DataSourceService;
    create(dataSource: T): Promise<T>;
    remove(dataSourceId: string): Promise<boolean>;
    clear(): Promise<void>;
    find(dataSourceId: string): Promise<T | null>;
    list<R = T>(filter?: FilterExpression): Promise<R[]>;
    count(filter?: FilterExpression): Promise<number>;
    query<R>(options: QueryOptions): Promise<QueryResult<R>>;
    scalar(options: ScalarOptions): Promise<number>;
}