import * as i0 from '@angular/core';
import { InjectionToken, ModuleWithProviders } from '@angular/core';
import { ApiConfig, Query, RequestType, TupleTypes, RequestOptions, ResultsResponse, StatisticsResponse } from '@spinque/query-api';
import { HttpParams, HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

declare const ApiConfigValue: InjectionToken<ApiConfig>;
/**
 * Main module of @spinque/angular-ui. Import with forRoot and pass an ApiConfig object.
 */
declare class SpinqueAngularUIModule {
    static forRoot(config: ApiConfig): ModuleWithProviders<SpinqueAngularUIModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpinqueAngularUIModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpinqueAngularUIModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpinqueAngularUIModule>;
}

/**
 * Function that will be called before making requests to the Spinque Query API.
 * Arguments passed are `queryStack`, `operation` and `options`.
 *
 * The function must return a RequestEnrichment, containing params, headers or other
 * options that will be added to the request made.
 */
type RequestEnrichmentFunc = (queryStack: Query | Query[], operation: RequestType, options: {
    [name: string]: any;
}) => Observable<RequestEnrichment>;
/**
 * Params, headers or other options to be added to a request.
 */
interface RequestEnrichment {
    params?: HttpParams | {
        [key: string]: any;
    };
    headers?: {
        ['Authorization']: string;
    };
    withCredentials?: boolean;
}
/**
 * Service to make requests to the Spinque Query API with.
 */
declare class SpinqueApiService {
    private config;
    private http;
    private requestEnrichtmentFuncs;
    constructor(config: ApiConfig, http: HttpClient);
    /**
     * Get the results of a query.
     */
    getResults<T = TupleTypes[]>(queries: Query | Query[], options?: RequestOptions, config?: ApiConfig): Observable<ResultsResponse<T>>;
    getResultPage<T = TupleTypes[]>(queries: Query | Query[], options?: RequestOptions, config?: ApiConfig): Observable<ResultsResponse<T>>;
    /**
     * Get the statistics of a query.
     */
    getStatistics(queries: Query | Query[], options?: RequestOptions, config?: ApiConfig): Observable<StatisticsResponse>;
    /**
     * Registers a function that is executed every time a request to the Spinque Query API
     * is made and can add params, header and other options to the request.
     */
    addRequestEnrichment(func: RequestEnrichmentFunc): void;
    /**
     * Underlies getResults and getStatistics
     */
    private fetch;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpinqueApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpinqueApiService>;
}

interface ImplicitTemplateVariableFromItemMapping<T> {
    $implicit: T;
    inferTypeFrom: (item: any) => T;
}
declare class InferTypeFromMappingForTemplateDirective<T> {
    itemMapping: (item: any) => T;
    static ngTemplateContextGuard<TContext>(_: InferTypeFromMappingForTemplateDirective<TContext>, ctx: unknown): ctx is ImplicitTemplateVariableFromItemMapping<TContext>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InferTypeFromMappingForTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InferTypeFromMappingForTemplateDirective<any>, "ng-template[inferTypeFrom]", never, { "itemMapping": { "alias": "inferTypeFrom"; "required": true; }; }, {}, never, never, true, never>;
}

export { ApiConfigValue, InferTypeFromMappingForTemplateDirective, SpinqueAngularUIModule, SpinqueApiService };
export type { ImplicitTemplateVariableFromItemMapping, RequestEnrichment, RequestEnrichmentFunc };