import * as i0 from '@angular/core';
import { OnDestroy, EventEmitter, DestroyRef, Type, InjectionToken } from '@angular/core';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import * as _fundamental_ngx_cdk_data_source from '@fundamental-ngx/cdk/data-source';

/**
 * Data source provider class controls the data stream.
 */
interface DataSourceProvider<T = any> {
    /**
     * Stream emits when new data has been requested.
     */
    dataRequested: Observable<boolean>;
    /**
     * Stream emits when new data has been loaded.
     */
    dataReceived: Observable<boolean>;
    /**
     * Stream emits when loading state has been changed.
     */
    dataLoading: Observable<boolean>;
    /** Stream emits when data changed. */
    dataChanges: Observable<T[]>;
    /** Closes the data stream. */
    unsubscribe(): void;
}

/**
 * Acceptable data source types.
 */
type DataSource<T = any, P extends DataSourceProvider<T> = DataSourceProvider<T>> = P | Observable<T[]> | T[];
/**
 * Data source parser is a special class that parses incoming data into appropriate data source provider.
 */
interface DataSourceParser<T = any, P extends DataSourceProvider<T> = DataSourceProvider<T>> {
    /**
     * Defines which data provider class to initiate.
     * @param source data source to be parsed.
     */
    parse(source: DataSource<T>): P | undefined;
}

declare enum MatchingStrategy {
    STARTS_WITH_PER_TERM = "starts with per term",
    STARTS_WITH = "starts with",
    CONTAINS = "contains"
}
type MatchBy = (item: any) => any;
interface MatchingBy {
    firstBy: MatchBy;
    secondaryBy?: MatchBy;
}

declare class DataSourceDirective<T = any, P extends DataSourceProvider<T> = DataSourceProvider<T>> implements OnDestroy {
    /**
     * Emits when the data source object has been changed.
     */
    readonly dataSourceChanged: EventEmitter<void>;
    /**
     * Event emitted when datasource content has been changed.
     */
    readonly dataChanged: EventEmitter<T[]>;
    /**
     * Event emitted when data provider loading state has been changed.
     */
    readonly isLoading: EventEmitter<boolean>;
    /**
     * Data source.
     * @param source
     */
    set dataSource(source: DataSource<T, P> | null);
    get dataSource(): DataSource<T, P> | null;
    /** @hidden */
    dataSourceProvider: P | undefined;
    /**
     * Data stream. Emits when new data retrieved.
     */
    readonly dataChanged$: BehaviorSubject<T[]>;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    private _dataSource;
    /** @hidden */
    private _dsSubscription;
    /** @hidden */
    private readonly _dataSourceTransformer;
    /** @hidden */
    ngOnDestroy(): void;
    /** @Hidden */
    protected _toDataStream(source: DataSource<T> | null): P | undefined;
    /** @hidden */
    private _initializeDataSource;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceDirective<any, any>, "[fdkDataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, { "dataSourceChanged": "dataSourceChanged"; "dataChanged": "dataChanged"; "isLoading": "isLoading"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class DataSourceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DataSourceModule, never, [typeof DataSourceDirective], [typeof DataSourceDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DataSourceModule>;
}

type ProviderParams = ReadonlyMap<string, any>;

/**
 * Base data provider class.
 */
declare abstract class AbstractDataProvider<T> {
    /** @hidden */
    abstract fetch(params: ProviderParams, start?: number, end?: number): Observable<T[]>;
    /** @hidden */
    abstract getTotalItems(params?: Map<string, any>): Observable<number>;
    /** @hidden */
    protected _keyPath: string;
    /** @hidden */
    protected _matchingStrategy: MatchingStrategy;
    /** @hidden */
    protected _matchingBy: MatchingBy | null;
    /** @hidden */
    setLookupKey(key: string): void;
    /** @hidden */
    setMatchingBy(matchingBy: MatchingBy): void;
    /** @hidden */
    setMatchingStrategy(strategy: MatchingStrategy): void;
}
/**
 * Default data provider class used for other components to extend from.
 */
declare class DataProvider<T> extends AbstractDataProvider<T> {
    protected values: Observable<T[]> | T[];
    /** Default limit for the pagination. */
    defaultLimit: number;
    /** @hidden */
    constructor(values: Observable<T[]> | T[]);
    /** @hidden */
    fetch(params: Map<string, any>): Observable<T[]>;
    /**
     * Returns observable with the number of total items that satisfy the search query.
     * Warning: this is a naive implementation of the number of the filtered items.
     * For real-world scenarios, it is recommended to override this method with its own logic.
     */
    getTotalItems(params: Map<string, any>): Observable<number>;
    /**
     * Warning: If you don't supply search Key and you want fulltext search, and you use this
     * default implementation, be aware that it can perform poorly as it is a naive implementation
     * that does not do deep compare.
     */
    matches(item: T, pattern: string): boolean;
    /** @hidden */
    matchesBy(item: any, pattern: string, matchingBy: MatchBy): boolean;
    /** @hidden */
    protected hasObjectValue(obj: any, pattern: string): boolean;
    /** @hidden */
    private withLimit;
}

declare abstract class BaseDataSource<T> implements DataSourceProvider<T> {
    dataProvider: AbstractDataProvider<any>;
    /**
     * Max limit of items to be returned.
     */
    static readonly MaxLimit = 5;
    /**
     * Whether to enable limit of max items.
     */
    limitless: boolean;
    /** @hidden */
    protected readonly _dataChanges$: BehaviorSubject<T[]>;
    /** @hidden */
    protected readonly _dataRequested$: BehaviorSubject<boolean>;
    /** @hidden */
    protected readonly _dataReceived$: BehaviorSubject<boolean>;
    /** @hidden */
    protected readonly _destroy$: Subject<void>;
    /** @hidden */
    protected readonly _dataLoading$: BehaviorSubject<boolean>;
    /**
     * Emitted when new data has been requested.
     * @returns Observable
     */
    get dataRequested(): Observable<boolean>;
    /**
     * Emitted when new data has been received.
     * @returns Observable
     */
    get dataReceived(): Observable<boolean>;
    /**
     * Emitted when loading state has been changed.
     * @returns Observable.
     */
    get dataLoading(): Observable<boolean>;
    /**
     * Emits when the data from the provider has been changed.
     * @returns Observable of data source objects.
     */
    get dataChanges(): Observable<T[]>;
    /** @hidden */
    protected constructor(dataProvider: AbstractDataProvider<any>);
    /**
     * Searches through the data source with defined parameters.
     * @param predicate Search query.
     * @param start start index.
     * @param end end index.
     */
    match(predicate?: string | Map<string, string>, start?: number, end?: number): void;
    /**
     * Returns the Observable of a total items number filtered by the `predicate` param.
     * @param predicate Search query.
     */
    getTotalItems(predicate?: string | Map<string, string>): Observable<number>;
    /**
     * Closes the stream
     */
    unsubscribe(): void;
    /** @hidden */
    private _getSearchParams;
}

declare const applyDatasourceDirective: Type<unknown> | {
    directive: Type<unknown>;
    inputs?: string[];
    outputs?: string[];
};

/**
 * Checks whether passed value is a valid data source.
 */
declare function isDataSource<T = any>(value: any): value is DataSourceProvider<T>;

/**
 * Injection token used for passing custom datasource transformer into DataSourceProvider.
 */
declare const FD_DATA_SOURCE_TRANSFORMER: InjectionToken<DataSourceParser<any, _fundamental_ngx_cdk_data_source.DataSourceProvider<any>>>;

export { AbstractDataProvider, BaseDataSource, DataProvider, DataSourceDirective, DataSourceModule, FD_DATA_SOURCE_TRANSFORMER, MatchingStrategy, applyDatasourceDirective, isDataSource };
export type { DataSource, DataSourceParser, DataSourceProvider, MatchBy, MatchingBy };