export declare class ClientResponse {
    private readonly statusVal;
    private readonly headersVal;
    private readonly bodyString;
    constructor(statusVal: number, headersVal: Headers, bodyString: string);
    status(): number;
    ok(): boolean;
    body(): string;
    json<T = any>(): T;
    headers(): Record<string, string>;
    header(name: string): string | null;
}
export declare class ResponseStub {
    readonly body: any;
    readonly status: number;
    readonly headers: Record<string, string>;
    constructor(body: any, status?: number, headers?: Record<string, string>);
    toResponse(): ClientResponse;
}
export declare class ResponseSequence {
    private stubs;
    private index;
    push(body: any, status?: number, headers?: Record<string, string>): this;
    pushCallback(callback: () => ResponseStub): this;
    next(): ClientResponse;
}
export declare class ClientRequest {
    private readonly urlVal;
    private readonly methodVal;
    private readonly headersVal;
    private readonly dataVal;
    constructor(urlVal: string, methodVal: string, headersVal: Record<string, string>, dataVal: any);
    url(): string;
    method(): string;
    headers(): Record<string, string>;
    hasHeader(name: string): boolean;
    header(name: string): string | undefined;
    data(): any;
}
export declare class PendingRequest {
    private readonly factory;
    private headersVal;
    private tokenVal?;
    private bodyFormat;
    private timeoutMs?;
    private retryTimes;
    private retryDelayMs;
    constructor(factory: HttpFactory);
    withHeaders(headers: Record<string, string>): this;
    withToken(token: string, type?: string): this;
    asJson(): this;
    asFormUrlEncoded(): this;
    timeout(ms: number): this;
    retry(times: number, delayMs?: number): this;
    get(url: string, query?: Record<string, any>): Promise<ClientResponse>;
    post(url: string, data?: any): Promise<ClientResponse>;
    put(url: string, data?: any): Promise<ClientResponse>;
    patch(url: string, data?: any): Promise<ClientResponse>;
    delete(url: string, data?: any): Promise<ClientResponse>;
    send(method: string, url: string, data?: any): Promise<ClientResponse>;
}
export type FakeCallback = (request: ClientRequest) => any;
export declare class HttpFactory {
    private fakeStubs;
    private fakingAll;
    private defaultFakeStub?;
    private recordedPairs;
    isFaking(): boolean;
    fake(stubs?: Record<string, any> | FakeCallback): this;
    response(body: any, status?: number, headers?: Record<string, string>): ResponseStub;
    sequence(): ResponseSequence;
    resolveFake(url: string, method: string, headers: Record<string, string>, data: any): ClientResponse;
    private resolveStubValue;
    record(request: ClientRequest, response: ClientResponse): void;
    clear(): void;
    assertSent(callback: (request: ClientRequest, response: ClientResponse) => boolean): void;
    assertNotSent(callback: (request: ClientRequest, response: ClientResponse) => boolean): void;
    assertNothingSent(): void;
    private newPendingRequest;
    withHeaders(headers: Record<string, string>): PendingRequest;
    withToken(token: string, type?: string): PendingRequest;
    asJson(): PendingRequest;
    asFormUrlEncoded(): PendingRequest;
    timeout(ms: number): PendingRequest;
    retry(times: number, delayMs?: number): PendingRequest;
    get(url: string, query?: Record<string, any>): Promise<ClientResponse>;
    post(url: string, data?: any): Promise<ClientResponse>;
    put(url: string, data?: any): Promise<ClientResponse>;
    patch(url: string, data?: any): Promise<ClientResponse>;
    delete(url: string, data?: any): Promise<ClientResponse>;
}
export declare function matchUrl(url: string, pattern: string): boolean;
export declare const Http: HttpFactory;
//# sourceMappingURL=client.d.ts.map