import { Cata } from './Basics';
import { Task, Cmd } from './index';
import Maybe from './Maybe';
import Either from './Either';
import Decode from './Json/Decode';
import Encode from './Json/Encode';
export declare abstract class Error {
    abstract cata<T>(pattern: Error.Pattern<T>): T;
}
export declare namespace Error {
    type Pattern<T> = Cata<{
        BadUrl(url: string): T;
        Timeout(): T;
        NetworkError(): T;
        BadStatus(response: Response<string>): T;
        BadBody(error: Decode.Error, response: Response<string>): T;
    }>;
    const BadUrl: (url: string) => Error;
    const Timeout: Error;
    const NetworkError: Error;
    const BadStatus: (response: Response<string>) => Error;
    const BadBody: (error: Decode.Error, response: Response<string>) => Error;
}
export declare class Header {
    protected readonly name: string;
    protected readonly value: string;
    protected constructor(name: string, value: string);
}
declare abstract class PhantomHeader extends Header {
    static of(name: string, value: string): Header;
    static getName(header: PhantomHeader): string;
    static getValue(header: PhantomHeader): string;
}
export declare const header: typeof PhantomHeader.of;
export interface Response<T> {
    readonly url: string;
    readonly statusCode: number;
    readonly statusText: string;
    readonly headers: {
        [name: string]: string;
    };
    readonly body: T;
}
export declare class Expect<T> {
    protected readonly responseType: XMLHttpRequestResponseType;
    protected readonly responseToResult: (response: Response<string>) => Either<Decode.Error, T>;
    protected constructor(responseType: XMLHttpRequestResponseType, responseToResult: (response: Response<string>) => Either<Decode.Error, T>);
}
export declare const expectResponse: <T>(responseToResult: (response: Response<string>) => Either<Decode.Error, T>) => Expect<T>;
export declare const expectWhatever: Expect<void>;
export declare const expectString: Expect<string>;
export declare const expectJson: <T>(decoder: Decode.Decoder<T>) => Expect<T>;
interface BodyContent {
    type: string;
    value: string;
}
export declare class Body {
    protected readonly content: Maybe<BodyContent>;
    protected constructor(content: Maybe<BodyContent>);
}
export declare const emptyBody: Body;
export declare const stringBody: (type: string, value: string) => Body;
export declare const jsonBody: (encoder: Encode.Value) => Body;
export declare class Request<T> {
    private readonly config;
    protected constructor(config: Readonly<{
        method: string;
        url: string;
        headers: Array<Header>;
        body: Body;
        expect: Expect<T>;
        timeout: Maybe<number>;
        withCredentials: boolean;
        queryParams: Array<[string, string]>;
    }>);
    withHeader(name: string, value: string): Request<T>;
    withHeaders(headers: Array<Header>): Request<T>;
    withBody(body: Body): Request<T>;
    withStringBody(type: string, value: string): Request<T>;
    withJsonBody(encoder: Encode.Value): Request<T>;
    withTimeout(timeout: number): Request<T>;
    withoutTimeout(): Request<T>;
    withCredentials(enabled: boolean): Request<T>;
    withQueryParam(key: string, value: string): Request<T>;
    withQueryParams(queries: Array<[string, string]>): Request<T>;
    withExpect<R>(expect: Expect<R>): Request<R>;
    withExpectResponse<R>(responseToResult: (response: Response<string>) => Either<Decode.Error, R>): Request<R>;
    withExpectString(): Request<string>;
    withExpectJson<R>(decoder: Decode.Decoder<R>): Request<R>;
    toTask(): Task<Error, T>;
    send<R>(tagger: (result: Either<Error, T>) => R): Cmd<R>;
}
export declare const get: (url: string) => Request<void>;
export declare const post: (url: string) => Request<void>;
export declare const put: (url: string) => Request<void>;
export declare const patch: (url: string) => Request<void>;
export declare const del: (url: string) => Request<void>;
export declare const options: (url: string) => Request<void>;
export declare const trace: (url: string) => Request<void>;
export declare const head: (url: string) => Request<void>;
export {};