import type { HttpRequest, HttpResponse } from "../http/index.js";
import type { HttpLayer } from "../layer/index.js";
import { type LogLevel } from "../logging/index.js";
import type { HttpService } from "../service/index.js";
/**
 * Interface used to classify a response.
 */
export type Classifier = {
    /**
     * Classify the response.
     *
     * If the response is successful, return null. Otherwise, return a
     * classification string for the response.
     */
    classifyResponse: (res: HttpResponse) => string | null;
};
/**
 * Interface used to tell {@link Trace} what to do when a request is received.
 */
export type OnRequest = {
    /**
     * Do the thing.
     */
    onRequest: (req: HttpRequest) => void;
};
/**
 * Interface used to tell {@link Trace} what to do when a response has been
 * produced.
 */
export type OnResponse = {
    /**
     * Do the thing.
     *
     * `latency` is the duration in milliseconds since the request was
     * received.
     */
    onResponse: (res: HttpResponse, latency: number) => void;
};
/**
 * Interface used to tell {@link Trace} what to do when a requests fails.
 */
export type OnFailure = {
    /**
     * Do the thing.
     *
     * `latency` is the duration in milliseconds since the request was
     * received.
     */
    onFailure: (classification: string, latency: number) => void;
};
export declare class ServerErrorAsFailureClassifier implements Classifier {
    classifyResponse(res: HttpResponse): string | null;
}
export declare class DefaultOnRequest implements OnRequest {
    private readonly level;
    constructor(level?: LogLevel);
    onRequest(_req: HttpRequest): void;
}
export declare class DefaultOnResponse implements OnResponse {
    private readonly level;
    private readonly includeHeaders;
    constructor(level?: LogLevel, includeHeaders?: boolean);
    onResponse(res: HttpResponse, latency: number): void;
}
export declare class DefaultOnFailure implements OnFailure {
    private readonly level;
    constructor(level?: LogLevel);
    onFailure(classification: string, latency: number): void;
}
/**
 * A layer that traces requests and responses.
 *
 * @example
 * ```ts
 * import { TraceLayer } from "@taxum/core/middleware/trace";
 * import { m, Router } from "@taxum/core/routing";
 *
 * const router = new Router()
 *     .route("/", m.get(() => "Hello World))
 *     .layer(new TraceLayer());
 * ```
 */
export declare class TraceLayer implements HttpLayer {
    private classifier_;
    private onRequest_;
    private onResponse_;
    private onFailure_;
    classifier(classifier: Classifier): this;
    onRequest(onRequest: OnRequest): this;
    onResponse(onResponse: OnResponse): this;
    onFailure(onFailure: OnFailure): this;
    layer(inner: HttpService): HttpService;
}
export declare class Trace implements HttpService {
    private readonly inner;
    private readonly classifier;
    private readonly onRequest;
    private readonly onResponse;
    private readonly onFailure;
    constructor(inner: HttpService, classifier: Classifier, onRequest: OnRequest, onResponse: OnResponse, onFailure: OnFailure);
    invoke(req: HttpRequest): Promise<HttpResponse>;
}