declare namespace _exports {
    export { ParamDef, Formatters, Checks, Params };
}
declare namespace _exports {
    export { $f };
    export { $f as formatters };
    export { $c };
    export { $c as checks };
    export namespace required {
        let required_1: boolean;
        export { required_1 as required };
    }
    export namespace string {
        let required_2: boolean;
        export { required_2 as required };
        export let type: string;
    }
    export namespace forcedString {
        let required_3: boolean;
        export { required_3 as required };
        export let formatters: ((value: any) => string)[];
    }
    export namespace forcedArr {
        let required_4: boolean;
        export { required_4 as required };
        let formatters_1: ((value: any) => any[])[];
        export { formatters_1 as formatters };
    }
    export namespace number {
        let required_5: boolean;
        export { required_5 as required };
        let type_1: string;
        export { type_1 as type };
    }
    export namespace integer {
        let required_6: boolean;
        export { required_6 as required };
        let type_2: string;
        export { type_2 as type };
        export let checks: ((value: any) => boolean)[];
    }
    export namespace boolean {
        let required_7: boolean;
        export { required_7 as required };
        let type_3: string;
        export { type_3 as type };
    }
    export namespace email {
        let required_8: boolean;
        export { required_8 as required };
        let type_4: string;
        export { type_4 as type };
        let formatters_2: ((value: any) => any)[];
        export { formatters_2 as formatters };
        let checks_1: ((value: any, name: any) => void)[];
        export { checks_1 as checks };
    }
    export namespace mac {
        let required_9: boolean;
        export { required_9 as required };
        let type_5: string;
        export { type_5 as type };
        let checks_2: ((value: any, name: any) => void)[];
        export { checks_2 as checks };
    }
    export namespace date {
        let required_10: boolean;
        export { required_10 as required };
        let formatters_3: ((value: any, name: any) => Date)[];
        export { formatters_3 as formatters };
    }
    export namespace uuid {
        let required_11: boolean;
        export { required_11 as required };
        let type_6: string;
        export { type_6 as type };
        let formatters_4: ((value: any, name: any) => any)[];
        export { formatters_4 as formatters };
    }
    export function _enum(...options: any[]): {
        required: boolean;
        formatters: ((value: any) => string)[];
        checks: ((value: any) => boolean)[];
    };
    export { _enum as enum };
    export function regexString(regex: any, valuetype?: string): {
        required: boolean;
        formatters: ((value: any) => string)[];
        checks: ((value: any, name: any) => void)[];
    };
    export namespace relativeTime {
        let required_12: boolean;
        export { required_12 as required };
        let formatters_5: ((value: any) => any)[];
        export { formatters_5 as formatters };
    }
    export namespace relativeDate {
        let required_13: boolean;
        export { required_13 as required };
        function _default(): Date;
        export { _default as default };
        export let ignoreEmptyString: boolean;
        let formatters_6: (((value: any) => any) | ((value: any, name: any) => Date))[];
        export { formatters_6 as formatters };
    }
    export namespace time {
        let required_14: boolean;
        export { required_14 as required };
        let type_7: string;
        export { type_7 as type };
        let formatters_7: ((value: any, name: any) => Date)[];
        export { formatters_7 as formatters };
    }
}
export = _exports;
type ParamDef = import("../routes/Route").ParamDef;
type Formatters = import("../params/formatters").Formatters;
type Checks = import("../params/checks").Checks;
type Params = {
    /**
     * - access to built-in formatters.
     */
    $f: Formatters;
    /**
     * - access to built-in formatters.
     */
    formatters: Formatters;
    /**
     * - access to built-in checks.
     */
    $c: Checks;
    /**
     * - access to built-in checks.
     */
    checks: Checks;
    /**
     * - Required param of any type.
     */
    required: ParamDef;
    /**
     * - Required param of type string.
     */
    string: ParamDef;
    /**
     * - Required param of any type, cast to string.
     * Useful if string can for instance be a number or similar.
     */
    forcedString: ParamDef;
    /**
     * - Required param of any type, cast to array.
     * Supports arrays, and commaseperated strings will be put into array.
     * All other values will be returned in array of length = 1.
     */
    forcedArr: ParamDef;
    /**
     * - Required param of type number.
     */
    number: ParamDef;
    /**
     * - Required param of type integer.
     * An integer can only be a whole number.
     */
    integer: ParamDef;
    /**
     * - Required param of type boolean.
     */
    boolean: ParamDef;
    /**
     * - Required param of type email.
     * An email is a properly email-formatted string.
     */
    email: ParamDef;
    /**
     * - Requird param of type mac-address.
     * A mac address is a properly mac formatted string. Can be in form of column or hyphen.
     */
    mac: ParamDef;
    /**
     * - Required param of type date.
     * A date is a properly formatted string that is formatted to date object.
     * Date can also be given in milliseconds after EPOCH.
     */
    date: ParamDef;
    /**
     * - Required param of type uuid.
     * A uuid is a uuid formatted conforming RFC4122. Braces are allowed
     * however, they will be automatically cut by the transformer.
     */
    uuid: ParamDef;
    /**
     * - Required param of type string,
     * where only the specified options are allowed. Hint: you can spread a string array
     * out by passing ...array.
     */
    enum: (...options: string) => ParamDef;
    /**
     * - Required param of type string,
     * which is only past if the specified RegExp passes successfully. Valuetype can be specified to give the
     * user a better hint of the variable type when the input does not match the regexp. Regular expression
     * must be passed as a javascript RegExp.
     */
    regexString: (regex: RegExp, valuetype: string) => ParamDef;
    /**
     * - Required param with relative time in millis.
     * Param ultimately returns a number. Param can be given as zeit/ms string.
     * IE: 555 => 555, "1s" => 1000 etc.
     */
    relativeTime: ParamDef;
    /**
     * - Param with relative input pointng to absolute datetime.
     * Param ultimately returns a Date object. Datetime is given in either
     * relative millis (-1000 is one second before now) or in zeit/ms string
     * ('2 days' is 2 days after now). Defaults to current datetime.
     */
    relativeDate: ParamDef;
    /**
     * - Required param of type string, formatted like
     * hh:mm with optional :ss. Transformed to datetime of current date with that
     * specified time.
     */
    time: ParamDef;
};
import $f = require("./formatters");
import $c = require("./checks");