/**
 * Definition of [[`Filter`]], the basic building block
 * @packageDocumentation
 */
import { Concat, Tuple } from "./types";
import { Error } from "./error";
import { Request } from ".";
/**
 * Return type of [[`FilterFn`]]
 */
export interface FilterRet<T extends Tuple> {
    /**
     * Extracted variables
     */
    tuple: T;
    /**
     * Weight
     */
    weight: number;
    /**
     * Depth
     */
    depth: number;
}
/**
 * Function run by [[`Filter`]] for each request
 *
 * @typeParam T - Extracted variables
 */
export declare type FilterFn<T extends Tuple> = (request: Request, weight: number, depth: number) => Promise<FilterRet<T>>;
/**
 * The base building block for all routes routes
 *
 * Filters extract variables from a request
 * and can be chained using the various combinator methods
 *
 * @typeParam T - Variables extracted by the filter (must have a known length)
 */
export declare class Filter<T extends Tuple> {
    /**
     * Function run for each request going through this filter
     */
    readonly run: FilterFn<T>;
    /**
     * Creates a new filter
     *
     * Unless you need a lot of flexibility, prefer the simpler [[`filter`]] function for cleaner code.
     * You also need to wrap the rejections manually when using this constructor,
     * which can be done using the [[`asError`]] function.
     *
     * @param f - [[`run`]] function
     */
    constructor(f: FilterFn<T>);
    /**
     * Creates a new filter that runs the current filter, then the provided filter,
     * then combines their extracted variables
     *
     * @param f - Other filter
     */
    and<U extends Tuple>(f: Filter<U>): Filter<Concat<T, U>>;
    /**
     * Creates a filter that runs the current filter,
     * or the provided filter if the current one fails
     *
     * @param f - Other filter
     */
    or(f: Filter<T>): Filter<T>;
    /**
     * Creates a filter that maps the previously extracted variables to new ones
     *
     * @param fn - Mapping function
     */
    map<U extends Tuple>(fn: Map<T, U>): Filter<U>;
    /**
     * Creates a filter that runs the current filter and handle possible errors
     *
     * @param fn - Recovery function
     */
    recover(fn: Recover<T>): Filter<T>;
    /**
     * Creates a filter that wraps the current filter
     *
     * @param fn - Wrapper function
     */
    with(fn: With<T>): Filter<T>;
}
/**
 * Mapping function used to convert previously extracted variables to something else
 *
 * @typeParam T - Previously extracted variables
 * @typeParam U - Mapped variables
 *
 * @returns - Either a function that returns the mapped variables or the mapped variables directly
 */
export declare type Map<T extends Tuple, U extends Tuple> = (...args: T) => Promise<Filter<U> | U>;
/**
 * Recovery function used to recover from errors
 *
 * @typeParam T - Extracted variables
 *
 * @returns New filter
 */
export declare type Recover<T extends Tuple> = (error: Error) => Promise<Filter<T> | T>;
/**
 * Wrapping function used to wrap some functionality around a filter
 *
 * @typeParam T - Extracted variables
 *
 * @returns Wrapped filter
 */
export declare type With<T extends Tuple> = (filter: Filter<T>) => Promise<Filter<T>>;
/**
 * Creates a new filter using the providing function
 *
 * @typeParam T - Extracted variables (must have a known length)
 *
 * @param fn - Function to pass requests through
 * @param weight - Weight of the filter (defaults to 1)
 */
export declare function filter<T extends Tuple>(fn: (request: Request) => Promise<T>, weight?: number): Filter<T>;
/**
 * Creates a new filter immediately extracting the provided variables
 *
 * @typeParam T - Extracted variables (must have a known length)
 *
 * @param value - Extracted variables
 * @param weight - Weight of the filter (defaults to 1)
 */
export declare function filter<T extends Tuple>(value: T, weight?: number): Filter<T>;