express-validator

const validationResult: ResultFactory<ValidationError> & {
    withDefaults: typeof withDefaults;
};

body: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

buildCheckFunction: (
    locations: Location[]
) => (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

check: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

checkExact: (
    chains?: CheckExactInput,
    opts?: CheckExactOptions
) => Middleware & ContextRunner;

checkSchema: <T extends string = DefaultSchemaKeys>(
    schema: Schema<T>,
    defaultLocations?: Location[]
) => RunnableValidationChains<ValidationChain>;

cookie: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

header: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

matchedData: <T extends object = Record<string, any>>(
    req: Request,
    options?: Partial<MatchedDataOptions>
) => T;

oneOf: (
    chains: (ValidationChain | ValidationChain[])[],
    options?: OneOfOptions
) => Middleware & ContextRunner;

param: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

query: (
    fields?: string | string[],
    message?: FieldMessageFactory | ErrorMessage
) => import('..').ValidationChain;

type AlternativeMessageFactory = (
    nestedErrors: FieldValidationError[],
    opts: {
        req: Request;
    }
) => any;

type AlternativeValidationError = {
    /**
     * Indicates that the error occurred because all alternatives (e.g. in `oneOf()`) were invalid
     */
    type: 'alternative';
    /**
     * The error message
     */
    msg: any;
    /**
     * The list of underlying validation errors returned by validation chains in `oneOf()`
     */
    nestedErrors: FieldValidationError[];
};

type CustomSanitizer = (input: any, meta: Meta) => any;

type CustomSchema<
    T extends ExpressValidator<any, any, any>,
    K extends string = DefaultSchemaKeys
> = T extends ExpressValidator<infer V, infer S, any>
    ? Record<
          string,
          ParamSchemaWithExtensions<
              Extract<keyof V, string>,
              Extract<keyof S, string>,
              K
          >
      >
    : never;

type CustomValidationChain<T extends ExpressValidator<any, any, any>> =
    T extends ExpressValidator<infer V, infer S, any>
        ? ValidationChainWithExtensions<Extract<keyof V | keyof S, string>>
        : never;

type CustomValidator = (input: any, meta: Meta) => any;

type ErrorFormatter<T = any> = (error: ValidationError) => T;

type FieldMessageFactory = (value: any, meta: Meta) => any;

type FieldValidationError = {
    /**
     * Indicates that the error occurred because a field had an invalid value
     */
    type: 'field';
    /**
     * The location within the request where this field is
     */
    location: Location;
    /**
     * The path to the field which has a validation error
     */
    path: string;
    /**
     * The value of the field. It might be unset if the value is hidden.
     */
    value?: any;
    /**
     * The error message
     */
    msg: any;
};

type GroupedAlternativeMessageFactory = (
    nestedErrors: FieldValidationError[][],
    opts: {
        req: Request;
    }
) => any;

type GroupedAlternativeValidationError = {
    /**
     * Indicates that the error occurred because all alternatives (e.g. in `oneOf()`) were invalid,
     * and the nested errors are grouped per alternative.
     */
    type: 'alternative_grouped';
    /**
     * The error message
     */
    msg: any;
    /**
     * The list of underlying validation errors returned by validation chains in `oneOf()`
     */
    nestedErrors: FieldValidationError[][];
};

type Location = 'body' | 'cookies' | 'headers' | 'params' | 'query';

type MatchedDataOptions = {
    /**
     * Whether the value returned by `matchedData()` should include data deemed optional.
     * @default false
     */
    includeOptionals: boolean;
    /**
     * An array of locations in the request to extract the data from.
     */
    locations: Location[];
    /**
     * Whether the value returned by `matchedData()` should include only values that have passed
     * validation.
     * @default true
     */
    onlyValidData: boolean;
};

type Meta = {
    /**
     * The express request from which the field was validated
     */
    req: Request;
    /**
     * Which of the request objects the field was picked from
     */
    location: Location;
    /**
     * The full path of the field within the request object.
     *
     * @example
     * const meta = { req, location: 'body', path: 'foo.bar' }; // req.body.foo.bar
     */
    path: string;
    /**
     * Values from wildcards/globstars used when selecting fields for validation.
     *
     * @example
     * body('products.*.price').custom((value, { req, pathValues }) => {
     *  const index = pathValues[0];
     *  const productName = req.body.products[index].name;
     * });
     */
    pathValues: readonly (string | string[])[];
};

type OneOfErrorType = 'grouped' | 'least_errored' | 'flat';

type OneOfOptions =
    | {
          /**
           * The error message to use in case none of the chains are valid.
           */
          message?: AlternativeMessageFactory | ErrorMessage;
          errorType?: Exclude<OneOfErrorType, 'grouped'>;
      }
    | {
          /**
           * The error message to use in case none of the chain groups are valid.
           */
          message?: GroupedAlternativeMessageFactory | ErrorMessage;
          errorType?: 'grouped';
      };

type ParamSchema<T extends string = DefaultSchemaKeys> = BaseParamSchema &
    ValidatorsSchema &
    SanitizersSchema & {
        [K in T]?: K extends keyof BaseParamSchema
            ? BaseParamSchema[K]
            : K extends keyof ValidatorsSchema
            ? ValidatorsSchema[K]
            : K extends keyof SanitizersSchema
            ? SanitizersSchema[K]
            : CustomValidatorSchemaOptions | CustomSanitizerSchemaOptions;
    };

type ParamSchemaWithExtensions<
    V extends string,
    S extends string,
    T extends string = DefaultSchemaKeys
> = {
    [K in keyof ParamSchema<T> | V | S]?: K extends V
        ? ExtensionValidatorSchemaOptions
        : K extends S
        ? ExtensionSanitizerSchemaOptions
        : K extends keyof ParamSchema<T>
        ? ParamSchema<T>[K]
        : never;
};

type ResultFactory<T> = (req: Request) => Result<T>;

type Schema<T extends string = DefaultSchemaKeys> = Record<string, ParamSchema<T>>;

type UnknownFieldMessageFactory = (
    unknownFields: UnknownFieldInstance[],
    opts: {
        req: Request;
    }
) => any;

type UnknownFieldsError = {
    /**
     * Indicates that the error occurred because one or more fields are unknown in the request
     */
    type: 'unknown_fields';
    /**
     * The error message
     */
    msg: any;
    /**
     * The list of fields that are unknown
     */
    fields: UnknownFieldInstance[];
};

type ValidationChainWithExtensions<T extends string> = Middleware & {
    [K in keyof ValidationChain]: ValidationChain[K] extends (
        ...args: infer A
    ) => ValidationChain
        ? (...params: A) => ValidationChainWithExtensions<T>
        : ValidationChain[K];
} & {
    [K in T]: () => ValidationChainWithExtensions<T>;
};

type ValidationError =
    | AlternativeValidationError
    | GroupedAlternativeValidationError
    | UnknownFieldsError
    | FieldValidationError;