@peppierre/typesafe-http-iots/index.d.ts

Type-safe HTTP client for Angular using io-ts and fp-ts

import { HttpHeaders, HttpContext, HttpParams, HttpClient, HttpEvent, HttpResponse } from '@angular/common/http';
import { Observable } from 'rxjs';
import * as iots from 'io-ts';
import * as i0 from '@angular/core';
import { Provider } from '@angular/core';

interface HttpOptionsBase<AllowedResponseType = undefined> {
    responseType?: AllowedResponseType;
    observe?: 'body' | 'events' | 'response' | undefined;
    headers?: HttpHeaders | Record<string, string | string[]> | undefined;
    context?: HttpContext | undefined;
    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]> | undefined;
    reportProgress?: boolean | undefined;
    withCredentials?: boolean | undefined;
    credentials?: RequestCredentials | undefined;
    keepalive?: boolean | undefined;
    priority?: RequestPriority | undefined;
    cache?: RequestCache | undefined;
    mode?: RequestMode | undefined;
    redirect?: RequestRedirect | undefined;
    referrer?: string | undefined;
    integrity?: string | undefined;
    transferCache?: boolean | {
        includeHeaders?: string[] | undefined;
    } | undefined;
    timeout?: number | undefined;
    body?: unknown;
}

type ArrayBufferBodyOptionsBase = HttpOptionsBase<'arraybuffer'> & {
    observe?: 'body' | undefined;
};
type ArrayBufferEventsOptionsBase = HttpOptionsBase<'arraybuffer'> & {
    observe: 'events';
};
type ArrayBufferResponseOptionsBase = HttpOptionsBase<'arraybuffer'> & {
    observe: 'response';
};
type BlobBodyOptionsBase = HttpOptionsBase<'blob'> & {
    observe?: 'body' | undefined;
};
type BlobEventsOptionsBase = HttpOptionsBase<'blob'> & {
    observe: 'events';
};
type BlobResponseOptionsBase = HttpOptionsBase<'blob'> & {
    observe: 'response';
};
type TextBodyOptionsBase = HttpOptionsBase<'text'> & {
    observe?: 'body' | undefined;
};
type TextEventsOptionsBase = HttpOptionsBase<'text'> & {
    observe: 'events';
};
type TextResponseOptionsBase = HttpOptionsBase<'text'> & {
    observe: 'response';
};
type JsonBodyOptionsBase = HttpOptionsBase<'json' | undefined> & {
    observe?: 'body' | undefined;
};
type JsonEventsOptionsBase = HttpOptionsBase<'json' | undefined> & {
    observe: 'events';
};
type JsonResponseOptionsBase = HttpOptionsBase<'json' | undefined> & {
    observe: 'response';
};
type JsonTypedOptionsBase<T> = JsonBodyOptionsBase & {
    runtimeType: iots.Type<T, unknown, unknown>;
};
type JsonEventsTypedOptionsBase<T> = JsonEventsOptionsBase & {
    runtimeType: iots.Type<T, unknown, unknown>;
};
type JsonResponseTypedOptionsBase<T> = JsonResponseOptionsBase & {
    runtimeType: iots.Type<T, unknown, unknown>;
};
type GetJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type DeleteJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type HeadJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type OptionsJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type PatchJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type PostJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type PutJsonTypedOptions<T> = JsonTypedOptionsBase<T>;
type GetJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type DeleteJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type HeadJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type OptionsJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type PatchJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type PostJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type PutJsonEventsTypedOptions<T> = JsonEventsTypedOptionsBase<T>;
type GetJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type DeleteJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type HeadJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type OptionsJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type PatchJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type PostJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type PutJsonResponseTypedOptions<T> = JsonResponseTypedOptionsBase<T>;
type GetArrayBufferOptions = ArrayBufferBodyOptionsBase;
type DeleteArrayBufferOptions = ArrayBufferBodyOptionsBase;
type HeadArrayBufferOptions = ArrayBufferBodyOptionsBase;
type OptionsArrayBufferOptions = ArrayBufferBodyOptionsBase;
type PatchArrayBufferOptions = ArrayBufferBodyOptionsBase;
type PostArrayBufferOptions = ArrayBufferBodyOptionsBase;
type PutArrayBufferOptions = ArrayBufferBodyOptionsBase;
type GetBlobOptions = BlobBodyOptionsBase;
type DeleteBlobOptions = BlobBodyOptionsBase;
type HeadBlobOptions = BlobBodyOptionsBase;
type OptionsBlobOptions = BlobBodyOptionsBase;
type PatchBlobOptions = BlobBodyOptionsBase;
type PostBlobOptions = BlobBodyOptionsBase;
type PutBlobOptions = BlobBodyOptionsBase;
type GetTextOptions = TextBodyOptionsBase;
type DeleteTextOptions = TextBodyOptionsBase;
type HeadTextOptions = TextBodyOptionsBase;
type OptionsTextOptions = TextBodyOptionsBase;
type PatchTextOptions = TextBodyOptionsBase;
type PostTextOptions = TextBodyOptionsBase;
type PutTextOptions = TextBodyOptionsBase;
type GetJsonOptions = JsonBodyOptionsBase;
type DeleteJsonOptions = JsonBodyOptionsBase;
type HeadJsonOptions = JsonBodyOptionsBase;
type OptionsJsonOptions = JsonBodyOptionsBase;
type PatchJsonOptions = JsonBodyOptionsBase;
type PostJsonOptions = JsonBodyOptionsBase;
type PutJsonOptions = JsonBodyOptionsBase;
type GetArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type DeleteArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type HeadArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type OptionsArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type PatchArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type PostArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type PutArrayBufferEventsOptions = ArrayBufferEventsOptionsBase;
type GetArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type DeleteArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type HeadArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type OptionsArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type PatchArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type PostArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type PutArrayBufferResponseOptions = ArrayBufferResponseOptionsBase;
type GetBlobEventsOptions = BlobEventsOptionsBase;
type DeleteBlobEventsOptions = BlobEventsOptionsBase;
type HeadBlobEventsOptions = BlobEventsOptionsBase;
type OptionsBlobEventsOptions = BlobEventsOptionsBase;
type PatchBlobEventsOptions = BlobEventsOptionsBase;
type PostBlobEventsOptions = BlobEventsOptionsBase;
type PutBlobEventsOptions = BlobEventsOptionsBase;
type GetBlobResponseOptions = BlobResponseOptionsBase;
type DeleteBlobResponseOptions = BlobResponseOptionsBase;
type HeadBlobResponseOptions = BlobResponseOptionsBase;
type OptionsBlobResponseOptions = BlobResponseOptionsBase;
type PatchBlobResponseOptions = BlobResponseOptionsBase;
type PostBlobResponseOptions = BlobResponseOptionsBase;
type PutBlobResponseOptions = BlobResponseOptionsBase;
type GetTextEventsOptions = TextEventsOptionsBase;
type DeleteTextEventsOptions = TextEventsOptionsBase;
type HeadTextEventsOptions = TextEventsOptionsBase;
type OptionsTextEventsOptions = TextEventsOptionsBase;
type PatchTextEventsOptions = TextEventsOptionsBase;
type PostTextEventsOptions = TextEventsOptionsBase;
type PutTextEventsOptions = TextEventsOptionsBase;
type GetTextResponseOptions = TextResponseOptionsBase;
type DeleteTextResponseOptions = TextResponseOptionsBase;
type HeadTextResponseOptions = TextResponseOptionsBase;
type OptionsTextResponseOptions = TextResponseOptionsBase;
type PatchTextResponseOptions = TextResponseOptionsBase;
type PostTextResponseOptions = TextResponseOptionsBase;
type PutTextResponseOptions = TextResponseOptionsBase;
type GetJsonEventsOptions = JsonEventsOptionsBase;
type DeleteJsonEventsOptions = JsonEventsOptionsBase;
type HeadJsonEventsOptions = JsonEventsOptionsBase;
type OptionsJsonEventsOptions = JsonEventsOptionsBase;
type PatchJsonEventsOptions = JsonEventsOptionsBase;
type PostJsonEventsOptions = JsonEventsOptionsBase;
type PutJsonEventsOptions = JsonEventsOptionsBase;
type GetJsonResponseOptions = JsonResponseOptionsBase;
type DeleteJsonResponseOptions = JsonResponseOptionsBase;
type HeadJsonResponseOptions = JsonResponseOptionsBase;
type OptionsJsonResponseOptions = JsonResponseOptionsBase;
type PatchJsonResponseOptions = JsonResponseOptionsBase;
type PostJsonResponseOptions = JsonResponseOptionsBase;
type PutJsonResponseOptions = JsonResponseOptionsBase;

declare class TypesafeHttpService {
    private http;
    constructor(http: HttpClient);
    delete(url: string, options: DeleteArrayBufferOptions): Observable<ArrayBuffer>;
    delete(url: string, options: DeleteArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    delete(url: string, options: DeleteArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    delete(url: string, options: DeleteBlobOptions): Observable<Blob>;
    delete(url: string, options: DeleteBlobEventsOptions): Observable<HttpEvent<Blob>>;
    delete(url: string, options: DeleteBlobResponseOptions): Observable<HttpResponse<Blob>>;
    delete(url: string, options: DeleteTextOptions): Observable<string>;
    delete(url: string, options: DeleteTextEventsOptions): Observable<HttpEvent<string>>;
    delete(url: string, options: DeleteTextResponseOptions): Observable<HttpResponse<string>>;
    delete(url: string, options?: DeleteJsonOptions | undefined): Observable<object>;
    delete(url: string, options: DeleteJsonEventsOptions): Observable<HttpEvent<object>>;
    delete(url: string, options: DeleteJsonResponseOptions): Observable<HttpResponse<object>>;
    delete<T>(url: string, options?: DeleteJsonTypedOptions<T> | undefined): Observable<T>;
    delete<T>(url: string, options: DeleteJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    delete<T>(url: string, options: DeleteJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    get(url: string, options: GetArrayBufferOptions): Observable<ArrayBuffer>;
    get(url: string, options: GetArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    get(url: string, options: GetArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    get(url: string, options: GetBlobOptions): Observable<Blob>;
    get(url: string, options: GetBlobEventsOptions): Observable<HttpEvent<Blob>>;
    get(url: string, options: GetBlobResponseOptions): Observable<HttpResponse<Blob>>;
    get(url: string, options: GetTextOptions): Observable<string>;
    get(url: string, options: GetTextEventsOptions): Observable<HttpEvent<string>>;
    get(url: string, options: GetTextResponseOptions): Observable<HttpResponse<string>>;
    get(url: string, options?: GetJsonOptions | undefined): Observable<object>;
    get(url: string, options: GetJsonEventsOptions): Observable<HttpEvent<object>>;
    get(url: string, options: GetJsonResponseOptions): Observable<HttpResponse<object>>;
    get<T>(url: string, options?: GetJsonTypedOptions<T> | undefined): Observable<T>;
    get<T>(url: string, options: GetJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    get<T>(url: string, options: GetJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    head(url: string, options: HeadArrayBufferOptions): Observable<ArrayBuffer>;
    head(url: string, options: HeadArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    head(url: string, options: HeadArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    head(url: string, options: HeadBlobOptions): Observable<Blob>;
    head(url: string, options: HeadBlobEventsOptions): Observable<HttpEvent<Blob>>;
    head(url: string, options: HeadBlobResponseOptions): Observable<HttpResponse<Blob>>;
    head(url: string, options: HeadTextOptions): Observable<string>;
    head(url: string, options: HeadTextEventsOptions): Observable<HttpEvent<string>>;
    head(url: string, options: HeadTextResponseOptions): Observable<HttpResponse<string>>;
    head(url: string, options?: HeadJsonOptions | undefined): Observable<object>;
    head(url: string, options: HeadJsonEventsOptions): Observable<HttpEvent<object>>;
    head(url: string, options: HeadJsonResponseOptions): Observable<HttpResponse<object>>;
    head<T>(url: string, options?: HeadJsonTypedOptions<T> | undefined): Observable<T>;
    head<T>(url: string, options: HeadJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    head<T>(url: string, options: HeadJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    options(url: string, options: OptionsArrayBufferOptions): Observable<ArrayBuffer>;
    options(url: string, options: OptionsArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    options(url: string, options: OptionsArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    options(url: string, options: OptionsBlobOptions): Observable<Blob>;
    options(url: string, options: OptionsBlobEventsOptions): Observable<HttpEvent<Blob>>;
    options(url: string, options: OptionsBlobResponseOptions): Observable<HttpResponse<Blob>>;
    options(url: string, options: OptionsTextOptions): Observable<string>;
    options(url: string, options: OptionsTextEventsOptions): Observable<HttpEvent<string>>;
    options(url: string, options: OptionsTextResponseOptions): Observable<HttpResponse<string>>;
    options(url: string, options?: OptionsJsonOptions | undefined): Observable<object>;
    options(url: string, options: OptionsJsonEventsOptions): Observable<HttpEvent<object>>;
    options(url: string, options: OptionsJsonResponseOptions): Observable<HttpResponse<object>>;
    options<T>(url: string, options?: OptionsJsonTypedOptions<T> | undefined): Observable<T>;
    options<T>(url: string, options: OptionsJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    options<T>(url: string, options: OptionsJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    patch(url: string, body: unknown, options: PatchArrayBufferOptions): Observable<ArrayBuffer>;
    patch(url: string, body: unknown, options: PatchArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    patch(url: string, body: unknown, options: PatchArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    patch(url: string, body: unknown, options: PatchBlobOptions): Observable<Blob>;
    patch(url: string, body: unknown, options: PatchBlobEventsOptions): Observable<HttpEvent<Blob>>;
    patch(url: string, body: unknown, options: PatchBlobResponseOptions): Observable<HttpResponse<Blob>>;
    patch(url: string, body: unknown, options: PatchTextOptions): Observable<string>;
    patch(url: string, body: unknown, options: PatchTextEventsOptions): Observable<HttpEvent<string>>;
    patch(url: string, body: unknown, options: PatchTextResponseOptions): Observable<HttpResponse<string>>;
    patch(url: string, body: unknown, options?: PatchJsonOptions | undefined): Observable<object>;
    patch(url: string, body: unknown, options: PatchJsonEventsOptions): Observable<HttpEvent<object>>;
    patch(url: string, body: unknown, options: PatchJsonResponseOptions): Observable<HttpResponse<object>>;
    patch<T>(url: string, body: unknown, options?: PatchJsonTypedOptions<T> | undefined): Observable<T>;
    patch<T>(url: string, body: unknown, options: PatchJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    patch<T>(url: string, body: unknown, options: PatchJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    post(url: string, body: any, options: PostArrayBufferOptions): Observable<ArrayBuffer>;
    post(url: string, body: any, options: PostArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    post(url: string, body: any, options: PostArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    post(url: string, body: any, options: PostBlobOptions): Observable<Blob>;
    post(url: string, body: any, options: PostBlobEventsOptions): Observable<HttpEvent<Blob>>;
    post(url: string, body: any, options: PostBlobResponseOptions): Observable<HttpResponse<Blob>>;
    post(url: string, body: any, options: PostTextOptions): Observable<string>;
    post(url: string, body: any, options: PostTextEventsOptions): Observable<HttpEvent<string>>;
    post(url: string, body: any, options: PostTextResponseOptions): Observable<HttpResponse<string>>;
    post(url: string, body: any, options?: PostJsonOptions | undefined): Observable<object>;
    post(url: string, body: any, options: PostJsonEventsOptions): Observable<HttpEvent<object>>;
    post(url: string, body: any, options: PostJsonResponseOptions): Observable<HttpResponse<object>>;
    post<T>(url: string, body: any, options?: PostJsonTypedOptions<T> | undefined): Observable<T>;
    post<T>(url: string, body: any, options: PostJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    post<T>(url: string, body: any, options: PostJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    put(url: string, body: any, options: PutArrayBufferOptions): Observable<ArrayBuffer>;
    put(url: string, body: any, options: PutArrayBufferEventsOptions): Observable<HttpEvent<ArrayBuffer>>;
    put(url: string, body: any, options: PutArrayBufferResponseOptions): Observable<HttpResponse<ArrayBuffer>>;
    put(url: string, body: any, options: PutBlobOptions): Observable<Blob>;
    put(url: string, body: any, options: PutBlobEventsOptions): Observable<HttpEvent<Blob>>;
    put(url: string, body: any, options: PutBlobResponseOptions): Observable<HttpResponse<Blob>>;
    put(url: string, body: any, options: PutTextOptions): Observable<string>;
    put(url: string, body: any, options: PutTextEventsOptions): Observable<HttpEvent<string>>;
    put(url: string, body: any, options: PutTextResponseOptions): Observable<HttpResponse<string>>;
    put(url: string, body: any, options?: PutJsonOptions | undefined): Observable<object>;
    put(url: string, body: any, options: PutJsonEventsOptions): Observable<HttpEvent<object>>;
    put(url: string, body: any, options: PutJsonResponseOptions): Observable<HttpResponse<object>>;
    put<T>(url: string, body: any, options?: PutJsonTypedOptions<T> | undefined): Observable<T>;
    put<T>(url: string, body: any, options: PutJsonEventsTypedOptions<T>): Observable<HttpEvent<T>>;
    put<T>(url: string, body: any, options: PutJsonResponseTypedOptions<T>): Observable<HttpResponse<T>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TypesafeHttpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TypesafeHttpService>;
}

declare function provideTypesafeHttp(): Provider;

export { TypesafeHttpService, provideTypesafeHttp };