import { Response, Headers } from "./fetch";
type ErrorBody = {
    error: string;
    message?: string;
    data?: any;
};
export declare class HttpCClientError extends Error {
    readonly status: number;
    readonly body?: ErrorBody | undefined;
    constructor(status: number, body?: ErrorBody | undefined);
    get error(): string | undefined;
    get data(): any;
}
export type HttpCClientOptions = {
    endpoint?: string;
    middlewares?: readonly (HttpCClientMiddleware | HttpCClientMiddlewareEntry)[];
};
export type HttpCClientMiddlewareEntry = {
    key: string;
    value: HttpCClientMiddleware;
};
export type HttpCClientRequest = {
    method: string;
    endpoint?: string;
    path?: string;
    query: URLSearchParams;
    headers: InstanceType<typeof Headers>;
    body?: any;
    metadata?: Record<string, any>;
};
export type HttpCClientResponse = InstanceType<typeof Response>;
type HttpCClientFetch = (request: HttpCClientRequest) => Promise<HttpCClientResponse>;
export type HttpCClientMiddleware = (request: HttpCClientRequest, next: HttpCClientFetch) => Promise<HttpCClientResponse>;
export declare class HttpCClient {
    protected _middlewares: HttpCClientMiddlewareEntry[];
    private _pipeline;
    constructor(options?: HttpCClientOptions);
    endpoint: string | undefined;
    use(middleware: HttpCClientMiddleware): this;
    use(key: string, middleware: HttpCClientMiddleware | null): this;
    call<T>(operation: string, ...args: any[]): Promise<T>;
    read<T>(operation: string, ...args: any[]): Promise<T>;
    write<T>(operation: string, ...args: any[]): Promise<T>;
    protected _send<TRes>(request: HttpCClientRequest): Promise<TRes>;
    protected _createRequest(method: string, pathAndQuery: string, data?: any): HttpCClientRequest;
    protected _fetch(request: HttpCClientRequest): Promise<HttpCClientResponse>;
    protected _raiseHttpError(status: number, body?: any): never;
}
export {};
//# sourceMappingURL=client.d.ts.map