import * as Angular from '@angular/common/http';
import { HttpContext, HttpParams } from '@angular/common/http';
import { HttpBackend, HttpEvent, HttpResponse } from '@opra/client';
import { Observable } from 'rxjs';
import { StrictOmit } from 'ts-gems';
import * as i0 from '@angular/core';
import { InjectionToken, NgModule, Type, ModuleWithProviders } from '@angular/core';

/**
 * Angular specific implementation of {@link HttpBackend} using Angular's HttpClient.
 *
 * @class AngularBackend
 */
declare class AngularBackend extends HttpBackend {
    readonly httpClient: Angular.HttpClient;
    /** Default request options */
    defaults: AngularBackend.RequestDefaults;
    /**
     * Creates a new instance of AngularBackend.
     *
     * @param httpClient The Angular HttpClient instance.
     * @param serviceUrl The base URL of the service.
     * @param options Configuration options.
     */
    constructor(httpClient: Angular.HttpClient, serviceUrl: string, options?: AngularBackend.Options);
    /**
     * Handles the HTTP request using Angular's HttpClient.
     *
     * @param init The request initialization parameters.
     * @returns An observable of {@link HttpEvent}.
     */
    handle(init: AngularBackend.RequestInit): Observable<HttpEvent>;
    /**
     * Sends the actual HTTP request.
     *
     * @param request The Angular HttpRequest instance.
     * @protected
     */
    protected send(request: Angular.HttpRequest<any>): Observable<Angular.HttpEvent<unknown>>;
    /**
     * Prepares the request by applying defaults and handling body content.
     *
     * @param init The initial request parameters.
     * @returns The prepared request initialization parameters.
     * @protected
     */
    protected prepareRequest(init: AngularBackend.RequestInit): AngularBackend.RequestInit;
    /**
     * Creates a {@link HttpResponse} instance.
     *
     * @param init The response initiator parameters.
     * @returns A new HttpResponse instance.
     * @protected
     */
    protected createResponse(init: HttpResponse.Initiator): HttpResponse;
    /**
     * Parses the response body based on Content-Type.
     *
     * @param fetchResponse The response to parse.
     * @returns The parsed body.
     * @protected
     */
    protected parseBody(fetchResponse: Response): Promise<any>;
}
/**
 * Namespace for {@link AngularBackend} related types and interfaces.
 *
 * @namespace AngularBackend
 */
declare namespace AngularBackend {
    /** Configuration options for AngularBackend */
    interface Options extends HttpBackend.Options {
        /** Default request options */
        defaults?: RequestDefaults;
    }
    /** Request initialization parameters for AngularBackend */
    interface RequestInit extends HttpBackend.RequestInit {
        /** Angular HttpContext */
        context?: HttpContext;
        /** Whether to report progress events */
        reportProgress?: boolean;
        /** Angular HttpParams */
        params?: HttpParams;
        /** The expected response type */
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
        /** Whether to send credentials with the request */
        withCredentials?: boolean;
    }
    /** Request options subset for AngularBackend */
    interface RequestOptions extends Pick<RequestInit, 'context' | 'reportProgress' | 'withCredentials'> {
    }
    /** Default request options for AngularBackend */
    type RequestDefaults = StrictOmit<RequestOptions, 'context'> & {
        /** Default headers */
        headers: Headers;
        /** Default URL parameters */
        params: URLSearchParams;
    };
}

type OpraClientModuleOptions = AngularBackend.Options & {
    serviceUrl: string;
    token?: string | InjectionToken<any>;
};
type _OpraClientModuleOptions = StrictOmit<OpraClientModuleOptions, 'token'>;
interface OpraModuleOptionsFactory {
    createOptions(): Promise<_OpraClientModuleOptions> | _OpraClientModuleOptions;
}
interface OpraClientModuleAsyncOptions extends Pick<NgModule, 'imports' | 'providers'> {
    token?: string | InjectionToken<any>;
    useExisting?: Type<OpraModuleOptionsFactory>;
    useClass?: Type<any>;
    useFactory?: (...args: any[]) => Promise<_OpraClientModuleOptions> | _OpraClientModuleOptions;
    deps?: any[];
}

/**
 * Angular module for OPRA client.
 */
declare class OpraClientModule {
    /**
     * Registers a client provider.
     *
     * @param options Configuration options for the client.
     * @returns A ModuleWithProviders instance.
     */
    static registerClient(options: OpraClientModuleOptions): ModuleWithProviders<OpraClientModule>;
    /**
     * Registers a service provider.
     *
     * @param serviceClass The service class to register.
     * @param options Configuration options for the service.
     * @returns A ModuleWithProviders instance.
     */
    static registerService<T>(serviceClass: Type<T>, options: OpraClientModuleOptions): ModuleWithProviders<OpraClientModule>;
    /**
     * Registers a client provider asynchronously.
     *
     * @param options Asynchronous configuration options for the client.
     * @returns A ModuleWithProviders instance.
     */
    static registerClientAsync(options: OpraClientModuleAsyncOptions): ModuleWithProviders<OpraClientModule>;
    /**
     * Registers a service provider asynchronously.
     *
     * @param serviceClass The service class to register.
     * @param options Asynchronous configuration options for the service.
     * @returns A ModuleWithProviders instance.
     */
    static registerServiceAsync<T>(serviceClass: Type<T>, options: OpraClientModuleAsyncOptions): ModuleWithProviders<OpraClientModule>;
    private static _createAsyncProviders;
    private static _createAsyncOptionsProvider;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpraClientModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpraClientModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpraClientModule>;
}

declare const OPRA_CLIENT_MODULE_OPTIONS = "OPRA_CLIENT_MODULE_OPTIONS";

export { AngularBackend, OPRA_CLIENT_MODULE_OPTIONS, OpraClientModule };
export type { OpraClientModuleAsyncOptions, OpraClientModuleOptions, OpraModuleOptionsFactory };