import * as i0 from '@angular/core';
import { OnInit, ElementRef, AfterViewInit, ChangeDetectorRef, ViewContainerRef, Renderer2 } from '@angular/core';
import { ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber } from '@lucca-front/ng/core';
import { ILuOptionOperator, LuOptionPickerAdvancedComponent, ILuOptionItem, LuOptionComparer } from '@lucca-front/ng/option';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import { HttpClient } from '@angular/common/http';
import { FormControl, ControlValueAccessor } from '@angular/forms';
import { Overlay } from '@angular/cdk/overlay';
import { ALuSelectInputComponent } from '@lucca-front/ng/select';

interface ILuApiSuggestion<T> {
    relevance: unknown;
    item: T;
}
interface ILuApiItem<TId = number> {
    id: TId;
    name?: string;
}
interface ILuApiResponse<D> {
    data: D;
}
type ILuApiCollectionResponse<T> = ILuApiResponse<{
    items: T[];
}>;

interface ILuApiService<T extends ILuApiItem = ILuApiItem> {
    getAll(filters?: string[]): Observable<T[]>;
    getPaged(page: number, filters?: string[]): Observable<T[]>;
    searchAll(clue: string, filters?: string[]): Observable<T[]>;
    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
}
declare abstract class ALuApiService<T extends ILuApiItem = ILuApiItem> implements ILuApiService<T> {
    abstract getAll(filters?: string[]): Observable<T[]>;
    abstract getPaged(page: number, filters?: string[]): Observable<T[]>;
    abstract searchAll(clue: string, filters?: string[]): Observable<T[]>;
    abstract searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
}

declare class LuApiV3Service<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
    protected _http: HttpClient;
    protected _api: string;
    set api(api: string);
    protected _fields: string;
    set fields(fields: string);
    protected _filters: string[];
    set filters(filters: string[]);
    protected _orderBy: string;
    set orderBy(orderBy: string);
    get url(): string;
    constructor(_http: HttpClient);
    getAll(filters?: string[]): Observable<T[]>;
    getPaged(page: number, filters?: string[]): Observable<T[]>;
    searchAll(clue: string, filters?: string[]): Observable<T[]>;
    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
    protected _get(url: string): Observable<T[]>;
    protected _clueFilter(clue: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiV3Service<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiV3Service<any>>;
}

declare class LuApiV4Service<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
    protected _http: HttpClient;
    protected _api: string;
    set api(api: string);
    protected _filters: string[];
    set filters(filters: string[]);
    get filters(): string[];
    protected _sort: string;
    set sort(sort: string);
    constructor(_http: HttpClient);
    getAll(filters?: string[]): Observable<T[]>;
    getPaged(page?: number, filters?: string[]): Observable<T[]>;
    searchAll(clue?: string, filters?: string[]): Observable<T[]>;
    searchPaged(clue?: string, page?: number, filters?: string[]): Observable<T[]>;
    count(): Observable<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiV4Service<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiV4Service<any>>;
}

declare class LuApiHybridService<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
    private _http;
    private _v3Service;
    private _v4Service;
    private _standard;
    set standard(std: 'v3' | 'v4');
    set api(api: string);
    set filters(filters: string[]);
    set fields(fields: string);
    set orderBy(orderBy: string);
    set sort(sort: string);
    private get _service();
    constructor(_http: HttpClient);
    getAll(filters?: string[]): Observable<T[]>;
    getPaged(page: number, filters?: string[]): Observable<T[]>;
    searchAll(clue: string, filters?: string[]): Observable<T[]>;
    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiHybridService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiHybridService<any>>;
}

type ILuApiOptionFeeder<T extends ILuApiItem = ILuApiItem> = ILuOptionOperator<T>;
interface ILuApiFeederService<T extends ILuApiItem = ILuApiItem> {
    getAll(): Observable<T[]>;
}
declare abstract class ALuApiOptionFeeder<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionFeeder<T> {
    outOptions$: BehaviorSubject<T[]>;
    protected _service: S;
    constructor(service: S);
    onOpen(): void;
}

declare class LuApiFeederComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionFeeder<T, LuApiHybridService<T>> implements ILuOptionOperator<T>, ILuOnOpenSubscriber {
    outOptions$: BehaviorSubject<T[]>;
    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
    set standard(standard: 'v3' | 'v4');
    set api(api: string);
    set fields(fields: string);
    set filters(filters: string[]);
    set orderBy(orderBy: string);
    set sort(sort: string);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiFeederComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiFeederComponent<any>, "lu-api-feeder", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
}

type ILuApiOptionSearcher<T extends ILuApiItem = ILuApiItem> = ILuApiOptionFeeder<T>;
declare abstract class ALuApiOptionSearcher<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionFeeder<T>, ILuOnOpenSubscriber {
    protected _service: S;
    outOptions$: Subject<T[]>;
    loading$: Observable<boolean>;
    empty$: Observable<boolean>;
    protected _clue$: Observable<string>;
    set clue$(clue$: Observable<string>);
    constructor(_service: S);
    init(): void;
    onOpen(): void;
    onClose(): void;
    protected initObservables(): void;
    abstract resetClue(): any;
    protected clearOptions(): void;
}
type ILuApiOptionPagedSearcher<T extends ILuApiItem = ILuApiItem> = ILuApiOptionSearcher<T>;
declare abstract class ALuApiOptionPagedSearcher<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> extends ALuApiOptionSearcher<T, S> implements ILuApiOptionPagedSearcher<T>, ILuOnScrollBottomSubscriber {
    outOptions$: Subject<T[]>;
    loading$: Observable<boolean>;
    protected _loading: boolean;
    protected _page$: Subject<void>;
    protected _isLastPage: boolean;
    protected _options: T[];
    constructor(service: S);
    onOpen(): void;
    onScrollBottom(): void;
    protected initObservables(): void;
    abstract resetClue(): any;
}

declare class LuApiSearcherComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionSearcher<T, LuApiHybridService<T>> implements OnInit {
    searchInput: ElementRef<HTMLElement>;
    set standard(standard: 'v3' | 'v4');
    set api(api: string);
    set fields(fields: string);
    set filters(filters: string[]);
    set orderBy(orderBy: string);
    set sort(sort: string);
    debounceTime: number;
    clueControl: FormControl;
    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
    ngOnInit(): void;
    onOpen(): void;
    resetClue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSearcherComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiSearcherComponent<any>, "lu-api-searcher", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; }, {}, never, never, true, never>;
}
declare class LuApiPagedSearcherComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionPagedSearcher<T, LuApiHybridService<T>> implements OnInit {
    searchInput: ElementRef<HTMLElement>;
    set standard(standard: 'v3' | 'v4');
    set api(api: string);
    set fields(fields: string);
    set filters(filters: string[]);
    set orderBy(orderBy: string);
    set sort(sort: string);
    debounceTime: number;
    clueControl: FormControl;
    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
    ngOnInit(): void;
    onOpen(): void;
    resetClue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagedSearcherComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiPagedSearcherComponent<any>, "lu-api-paged-searcher", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum Strategy {
    append = 0,
    replace = 1
}
type ILuApiOptionPager<T extends ILuApiItem = ILuApiItem> = ILuOptionOperator<T>;
interface ILuApiPagerService<T extends ILuApiItem = ILuApiItem> {
    getPaged(page: number): Observable<T[]>;
}
declare abstract class ALuApiOptionPager<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionPager<T>, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber {
    protected _service: S;
    outOptions$: Subject<T[]>;
    loading$: Observable<boolean>;
    protected _loading: boolean;
    protected _results$: Observable<{
        items: T[];
        strategy: Strategy;
    }>;
    protected _options: T[];
    protected _page$: Subject<number>;
    protected _page: number;
    protected _initialized: boolean;
    constructor(_service: S);
    protected init(): void;
    onOpen(): void;
    onScrollBottom(): void;
    protected initObservables(): void;
}

declare class LuApiPagerComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionPager<T, LuApiHybridService<T>> implements ILuOptionOperator<T>, OnInit, ILuOnScrollBottomSubscriber, ILuOnOpenSubscriber {
    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
    set standard(standard: 'v3' | 'v4');
    set api(api: string);
    set fields(fields: string);
    set filters(filters: string[]);
    set orderBy(orderBy: string);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagerComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiPagerComponent<any>, "lu-api-pager", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuApiSelectInputComponent<T extends ILuApiItem = ILuApiItem> extends ALuSelectInputComponent<T, LuOptionPickerAdvancedComponent<T, ILuOptionItem<T>>> implements ControlValueAccessor, AfterViewInit {
    protected _changeDetectorRef: ChangeDetectorRef;
    protected _overlay: Overlay;
    protected _elementRef: ElementRef<HTMLElement>;
    protected _viewContainerRef: ViewContainerRef;
    protected _renderer: Renderer2;
    standard: 'v3' | 'v4';
    api: string;
    /**
     * only works with standard="v3"
     */
    fields: string;
    filters: string[];
    /**
     * only works with standard="v3", otherwise use sort
     */
    orderBy: string;
    /**
     * only works with standard="v4", otherwise use orderBy
     */
    sort: string;
    byId: LuOptionComparer<T>;
    constructor(_changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectInputComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiSelectInputComponent<any>, "lu-api-select", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuApiFeederComponent, LuApiPagedSearcherComponent, LuApiSearcherComponent, LuApiPagerComponent, LuApiSelectInputComponent` instead
 */
declare class LuApiSelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectModule, never, [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent], [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSelectModule>;
}

/**
 * @deprecated use `LuApiFeederComponent, LuApiPagedSearcherComponent, LuApiSearcherComponent, LuApiPagerComponent, LuApiSelectInputComponent` instead
 */
declare class LuApiModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiModule, never, [typeof LuApiSelectModule], [typeof LuApiSelectModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiModule>;
}

/**
 * @deprecated use `LuApiPagedSearcherComponent, LuApiSearcherComponent` instead
 */
declare class LuApiSearcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSearcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSearcherModule, never, [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent], [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSearcherModule>;
}

/**
 * @deprecated use `LuApiSelectInputComponent` instead
 */
declare class LuApiSelectInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectInputModule, never, [typeof LuApiSelectInputComponent], [typeof LuApiSelectInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSelectInputModule>;
}

export { ALuApiOptionFeeder, ALuApiOptionPagedSearcher, ALuApiOptionPager, ALuApiOptionSearcher, ALuApiService, LuApiFeederComponent, LuApiHybridService, LuApiModule, LuApiPagedSearcherComponent, LuApiPagerComponent, LuApiSearcherComponent, LuApiSearcherModule, LuApiSelectInputComponent, LuApiSelectInputModule, LuApiSelectModule, LuApiV3Service, LuApiV4Service };
export type { ILuApiCollectionResponse, ILuApiFeederService, ILuApiItem, ILuApiOptionFeeder, ILuApiOptionPagedSearcher, ILuApiOptionPager, ILuApiOptionSearcher, ILuApiPagerService, ILuApiResponse, ILuApiService, ILuApiSuggestion };