How to update validator package inside core ?

[popovicieduard]

When using validator I get typescript error on range and my runtime error looks like this: Validator_1.rules.range is not a function

I expect this is because the range rule is not defined.

my package.json:

{
  "name": "test",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "build": "node ace build",
    "start": "node ace serve --watch",
    "lint": "eslint . --ext=.ts"
  },
  "devDependencies": {
    "@adonisjs/assembler": "^2.1.3",
    "adonis-preset-ts": "^1.0.4",
    "eslint": "^7.5.0",
    "eslint-plugin-adonis": "^1.0.14",
    "pino-pretty": "^4.1.0",
    "typescript": "^3.9.7",
    "youch": "^2.0.10",
    "youch-terminal": "^1.0.0"
  },
  "dependencies": {
    "@adonisjs/ace": "^6.9.3",
    "@adonisjs/auth": "^4.2.4",
    "@adonisjs/core": "^5.0.0-preview-rc-1.9",
    "@adonisjs/fold": "^6.3.5",
    "@adonisjs/lucid": "^8.2.2",
    "@adonisjs/mail": "^4.2.1",
    "@adonisjs/view": "^2.0.7",
    "adonis-lucid-filter": "^2.0.0-rc8",
    "camelcase-keys": "^6.2.2",
    "jsonwebtoken": "^8.5.1",
    "moment": "^2.27.0",
    "mysql": "^2.18.1",
    "proxy-addr": "^2.0.6",
    "reflect-metadata": "^0.1.13",
    "short-uuid": "^3.1.1",
    "snakecase-keys": "^3.2.0",
    "source-map-support": "^0.5.19",
    "uuid": "^8.2.0"
  }
}

and node_modules package.json from core:

{
  "_args": [
    [
      "@adonisjs/[email protected]",
      "E:\\Upboost\\Upnance-ts"
    ]
  ],
  "_from": "@adonisjs/[email protected]",
  "_id": "@adonisjs/[email protected]",
  "_inBundle": false,
  "_integrity": "sha512-VEUVcAb7hqhaJ2/XLwwn/sZQj6G3TM7CGK1X4aUZQ9YSbmfdFo2/z/MP+RQaz07WclMN07GLlJ1zWOFD3TcOJw==",
  "_location": "/@adonisjs/core",
  "_phantomChildren": {},
  "_requested": {
    "type": "version",
    "registry": true,
    "raw": "@adonisjs/[email protected]",
    "name": "@adonisjs/core",
    "escapedName": "@adonisjs%2fcore",
    "scope": "@adonisjs",
    "rawSpec": "5.0.0-preview-rc-1.9",
    "saveSpec": null,
    "fetchSpec": "5.0.0-preview-rc-1.9"
  },
  "_requiredBy": [
    "/"
  ],
  "_resolved": "https://registry.npmjs.org/@adonisjs/core/-/core-5.0.0-preview-rc-1.9.tgz",
  "_spec": "5.0.0-preview-rc-1.9",
  "_where": "E:\\Upboost\\Upnance-ts",
  "adonisjs": {
    "instructions": "./build/instructions.js",
    "templates": {
      "basePath": "./build/templates",
      "config": [
        {
          "src": "config/bodyparser.txt",
          "dest": "bodyparser"
        },
        {
          "src": "config/cors.txt",
          "dest": "cors"
        },
        {
          "src": "config/hash.txt",
          "dest": "hash"
        }
      ],
      "contracts": [
        {
          "src": "contracts/events.txt",
          "dest": "events"
        },
        {
          "src": "contracts/hash.txt",
          "dest": "hash"
        }
      ]
    },
    "commands": [
      "@adonisjs/core/build/commands"
    ],
    "types": "@adonisjs/core",
    "providers": [
      "@adonisjs/core"
    ]
  },
  "author": {
    "name": "virk,adonisjs"
  },
  "bugs": {
    "url": "https://github.com/adonisjs/adonis-framework/issues"
  },
  "config": {
    "commitizen": {
      "path": "cz-conventional-changelog"
    }
  },
  "dependencies": {
    "@adonisjs/application": "^1.3.15",
    "@adonisjs/bodyparser": "^4.0.4",
    "@adonisjs/config": "^1.0.16",
    "@adonisjs/encryption": "^2.0.4",
    "@adonisjs/env": "^1.0.17",
    "@adonisjs/events": "^2.0.3",
    "@adonisjs/hash": "^3.1.1",
    "@adonisjs/http-server": "^2.1.2",
    "@adonisjs/logger": "^2.0.6",
    "@adonisjs/profiler": "^3.0.4",
    "@adonisjs/validator": "^7.3.2",
    "@poppinss/utils": "^2.2.7",
    "@types/find-package-json": "^1.1.1",
    "cli-table3": "^0.6.0",
    "find-package-json": "^1.2.0",
    "semver": "^7.3.2",
    "serve-static": "^1.14.1"
  },
  "description": "Adonisjs core",
  "devDependencies": {
    "@adonisjs/ace": "^6.9.3",
    "@adonisjs/assembler": "^2.1.2",
    "@adonisjs/fold": "^6.3.5",
    "@adonisjs/mrm-preset": "^2.3.0",
    "@adonisjs/sink": "^3.0.2",
    "@poppinss/dev-utils": "^1.0.6",
    "@types/node": "^14.0.13",
    "@types/supertest": "^2.0.9",
    "commitizen": "^4.1.2",
    "copyfiles": "^2.3.0",
    "cz-conventional-changelog": "^3.2.0",
    "del-cli": "^3.0.1",
    "doctoc": "^1.4.0",
    "eslint": "^7.2.0",
    "eslint-plugin-adonis": "^1.0.10",
    "husky": "^4.2.5",
    "japa": "^3.1.1",
    "mrm": "^2.3.3",
    "np": "^6.2.4",
    "reflect-metadata": "^0.1.13",
    "strip-ansi": "^6.0.0",
    "supertest": "^4.0.2",
    "test-console": "^1.1.0",
    "ts-node": "^8.10.2",
    "typescript": "^3.9.5",
    "youch": "^2.0.10",
    "youch-terminal": "^1.0.0"
  },
  "files": [
    "build/adonis-typings",
    "build/templates",
    "build/commands",
    "build/providers",
    "build/src",
    "build/instructions.js"
  ],
  "homepage": "https://github.com/adonisjs/adonis-framework#readme",
  "husky": {
    "hooks": {
      "commit-msg": "node ./node_modules/@adonisjs/mrm-preset/validateCommit/conventional/validate.js"
    }
  },
  "keywords": [
    "adonisjs",
    "framework",
    "mvc"
  ],
  "license": "MIT",
  "main": "build/providers/AppProvider.js",
  "name": "@adonisjs/core",
  "np": {
    "contents": ".",
    "anyBranch": false
  },
  "nyc": {
    "exclude": [
      "test"
    ],
    "extension": [
      ".ts"
    ]
  },
  "peerDependencies": {
    "@adonisjs/fold": "^6.0.0",
    "@adonisjs/ace": "^6.0.0"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/adonisjs/adonis-framework.git"
  },
  "scripts": {
    "build": "npm run compile",
    "clean": "del build",
    "commit": "git-cz",
    "compile": "npm run lint && npm run clean && tsc && copyfiles templates/**/* build",
    "lint": "eslint . --ext=.ts",
    "mrm": "mrm --preset=@adonisjs/mrm-preset",
    "pretest": "npm run lint",
    "release": "np",
    "test": "node japaFile.js",
    "version": "npm run build"
  },
  "types": "./build/adonis-typings/index.d.ts",
  "version": "5.0.0-preview-rc-1.9"
}

and node_modules adonis validator package.json:

{
  "_args": [
    [
      "@adonisjs/[email protected]",
      "E:\\Upboost\\Upnance-ts"
    ]
  ],
  "_from": "@adonisjs/[email protected]",
  "_id": "@adonisjs/[email protected]",
  "_inBundle": false,
  "_integrity": "sha512-V9TlYG8B63k44ABTDCr5f2ttZY7LyGTqUNvfnfW4F4BA63Mlh5bYtyGJ4/AzZCDxWzTul0nASyCN3BgogRAsoA==",
  "_location": "/@adonisjs/validator",
  "_phantomChildren": {},
  "_requested": {
    "type": "version",
    "registry": true,
    "raw": "@adonisjs/[email protected]",
    "name": "@adonisjs/validator",
    "escapedName": "@adonisjs%2fvalidator",
    "scope": "@adonisjs",
    "rawSpec": "7.3.2",
    "saveSpec": null,
    "fetchSpec": "7.3.2"
  },
  "_requiredBy": [
    "/@adonisjs/core"
  ],
  "_resolved": "https://registry.npmjs.org/@adonisjs/validator/-/validator-7.3.2.tgz",
  "_spec": "7.3.2",
  "_where": "E:\\Upboost\\Upnance-ts",
  "author": {
    "name": "virk,adonisjs"
  },
  "bugs": {
    "url": "https://github.com/adonisjs/adonis-validation-provider/issues"
  },
  "config": {
    "commitizen": {
      "path": "cz-conventional-changelog"
    }
  },
  "dependencies": {
    "@poppinss/utils": "^2.2.7",
    "@types/luxon": "^1.24.0",
    "@types/validator": "^13.0.0",
    "endent": "^2.0.1",
    "luxon": "^1.24.1",
    "pope": "^2.0.2",
    "validator": "^13.1.1"
  },
  "description": "Validator for adonis framework",
  "devDependencies": {
    "@adonisjs/bodyparser": "^3.2.4",
    "@adonisjs/encryption": "^2.0.4",
    "@adonisjs/fold": "^6.3.5",
    "@adonisjs/http-server": "^2.1.2",
    "@adonisjs/logger": "^2.0.6",
    "@adonisjs/mrm-preset": "^2.3.0",
    "@adonisjs/profiler": "^3.0.4",
    "@hapi/joi": "^17.1.1",
    "@types/node": "^14.0.13",
    "benchmark": "^2.1.4",
    "class-validator": "^0.12.2",
    "commitizen": "^4.1.2",
    "cz-conventional-changelog": "^3.2.0",
    "del-cli": "^3.0.1",
    "eslint": "^7.2.0",
    "eslint-plugin-adonis": "^1.0.10",
    "execa": "^4.0.2",
    "husky": "^4.2.5",
    "indicative": "^7.4.4",
    "japa": "^3.1.1",
    "kleur": "^4.0.0",
    "mrm": "^2.3.3",
    "np": "^6.2.4",
    "ts-node": "^8.10.2",
    "typescript": "^3.9.5"
  },
  "files": [
    "build/adonis-typings",
    "build/providers",
    "build/src"
  ],
  "homepage": "https://github.com/adonisjs/adonis-validation-provider#readme",
  "husky": {
    "hooks": {
      "commit-msg": "node ./node_modules/@adonisjs/mrm-preset/validateCommit/conventional/validate.js"
    }
  },
  "keywords": [
    "validator",
    "schema-validation",
    "adonis",
    "indicative"
  ],
  "license": "MIT",
  "main": "build/providers/ValidatorProvider.js",
  "name": "@adonisjs/validator",
  "np": {
    "contents": ".",
    "anyBranch": false
  },
  "nyc": {
    "exclude": [
      "test"
    ],
    "extension": [
      ".ts"
    ]
  },
  "peerDependencies": {
    "@adonisjs/http-server": "^2.0.0"
  },
  "peerDependenciesMeta": {
    "@adonisjs/http-server": {
      "optional": true
    }
  },
  "publishConfig": {
    "access": "public",
    "tag": "alpha"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/adonisjs/adonis-validation-provider.git"
  },
  "scripts": {
    "benchmarks": "node build/benchmarks/index.js",
    "build": "npm run compile",
    "clean": "del build",
    "commit": "git-cz",
    "compile": "npm run lint && npm run clean && tsc",
    "copy:files": "copyfiles \"templates/**/*.txt\" build",
    "lint": "eslint . --ext=.ts",
    "mrm": "mrm --preset=@adonisjs/mrm-preset",
    "prepublishOnly": "npm run build",
    "pretest": "npm run lint",
    "release": "np",
    "test": "node japaFile.js",
    "version": "npm run build"
  },
  "types": "./build/adonis-typings/index.d.ts",
  "version": "7.3.2"
}

The version is up-to-date with: https://github.com/adonisjs/validator but the node_modules/@adonisjs/validator/build/adonis-typings/validator.d.ts is different from the one on github:

node_modules adonis-typings:

/// <reference types="validator" />
declare module '@ioc:Adonis/Core/Validator' {
    import { DateTime } from 'luxon';
    import { UUIDVersion } from 'validator/lib/isUUID';
    import { default as validatorJs } from 'validator';
    import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
    import { MultipartFileContract, FileValidationOptions } from '@ioc:Adonis/Core/BodyParser';
    /**
     * Helper
     */
    type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
    /**
     * Shape of a rule. This is what methods from the
     * rules object returns
     */
    export type Rule = {
        name: string;
        options?: any;
    };
    export type SchemaRef<T extends unknown> = {
        readonly __$isRef: true;
        value: T;
        key: string;
    };
    /**
     * The shape of rule after it has been passed
     */
    export type ParsedRule<Options extends any = any> = {
        name: string;
        async: boolean;
        allowUndefineds: boolean;
        compiledOptions: Options;
    };
    /**
     * Shape of schema core literal type
     */
    export type SchemaLiteral = {
        type: 'literal';
        subtype: string;
        rules: ParsedRule[];
    };
    /**
     * Shape of schema core object type
     */
    export type SchemaObject = {
        type: 'object';
        rules: ParsedRule[];
        children: ParsedSchemaTree;
    };
    /**
     * Shape of schema core array type
     */
    export type SchemaArray = {
        type: 'array';
        rules: ParsedRule[];
        each?: SchemaLiteral | SchemaObject | SchemaArray;
    };
    /**
     * Shape of parsed schema tree. This is not extensible. All newly
     * added rules will be of type literal.
     */
    export type ParsedSchemaTree = {
        [key: string]: SchemaLiteral | SchemaObject | SchemaArray;
    };
    /**
     * The runtime values passed to a validation runtime
     */
    export type ValidationRuntimeOptions = {
        root: any;
        tip: any;
        field: string;
        pointer: string;
        refs: {
            [key: string]: SchemaRef<unknown>;
        };
        arrayExpressionPointer?: string;
        errorReporter: ErrorReporterContract;
        mutate: ((newValue: any) => void);
    };
    export type NodeType = 'array' | 'object' | 'literal';
    export type NodeSubType = Exclude<keyof Schema, 'create' | 'refs'>;
    /**
     * Compiler internal representation of a field to produce
     * the compiled output
     */
    export type ValidationField = {
        name: string;
        type: 'literal' | 'identifier';
    };
    /**
     * Shape of an async validation function
     */
    export type AsyncValidation<T extends any = unknown> = {
        compile(type: NodeType, subtype: NodeSubType, options?: any): ParsedRule<T>;
        validate(value: any, compiledOptions: T, runtimeOptions: ValidationRuntimeOptions): Promise<void>;
    };
    /**
     * Shape of an sync validation function
     */
    export type SyncValidation<T extends any = unknown> = {
        compile(type: NodeType, subtype: NodeSubType, options?: any): ParsedRule<T>;
        validate(value: any, compiledOptions: T, runtimeOptions: ValidationRuntimeOptions): void;
    };
    /**
     * Shape of custom messages accepted the validator
     */
    export type CustomMessages = {
        '*'?: ((field: string, rule: string, arrayExpressionPointer?: string, args?: any) => string);
    } | {
        [key: string]: string;
    };
    /**
     * Returns the most appropriate message for the current
     * validation error.
     */
    export interface MessagesBagContract {
        get(pointer: string, rule: string, message: string, arrayExpressionPointer?: string, args?: any): string;
    }
    /**
     * The interface that every error reporter must adhere
     * to.
     */
    export interface ErrorReporterContract<Messages extends any = any> {
        hasErrors: boolean;
        report(pointer: string, rule: string, message?: string, arrayExpressionPointer?: string, args?: any): void;
        toError(): any;
        toJSON(): Messages;
    }
    /**
     * The reporter constructor contract
     */
    export interface ErrorReporterConstructorContract<Messages extends any = any> {
        new (messages: MessagesBagContract, bail: boolean): ErrorReporterContract<Messages>;
    }
    /**
     * Shape of the JSON API error node
     */
    export type JsonApiErrorNode = {
        source: {
            pointer: string;
        };
        code: string;
        title: string;
        meta?: any;
    };
    /**
     * Shape of the API error node
     */
    export type ApiErrorNode = {
        message: string;
        field: string;
        rule: string;
        args?: any;
    };
    /**
     * Shape of the Vanilla error node
     */
    export type VanillaErrorNode = {
        [field: string]: string[];
    };
    /**
     * The contract every validation must adhere to
     */
    export type ValidationContract<T> = AsyncValidation<T> | SyncValidation<T>;
    /**
     * The compiler output function
     */
    export interface CompilerOutput<T extends any> {
        (data: any, validations: {
            [rule: string]: ValidationContract<any>;
        }, errorReporter: ErrorReporterContract, helpers: {
            exists: ((value: any) => boolean);
            isObject: ((value: any) => boolean);
        }, refs: {
            [key: string]: SchemaRef<unknown>;
        }): Promise<T>;
    }
    /**
     * Typed schema is a key-value pair of the `field` and a schema
     * function that returns `getTree` method and optional `type`
     * for it
     */
    export type TypedSchema = {
        [field: string]: {
            t?: any;
            getTree(): SchemaLiteral | SchemaObject | SchemaArray;
        };
    };
    /**
     * Signature to define a string or optional string type
     */
    export interface StringType {
        (options?: {
            escape?: boolean;
            trim?: boolean;
        }, rules?: Rule[]): {
            t: string;
            getTree(): SchemaLiteral;
        };
        optional(options?: {
            escape?: boolean;
            trim?: boolean;
        }, rules?: Rule[]): {
            t?: string;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Signature to define a date or an optional date type
     */
    export interface DateType {
        (options?: {
            format?: string;
        }, rules?: Rule[]): {
            t: DateTime;
            getTree(): SchemaLiteral;
        };
        optional(options?: {
            format?: string;
        }, rules?: Rule[]): {
            t?: DateTime;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Signature to define a boolean or optional boolean type
     */
    export interface BooleanType {
        (rules?: Rule[]): {
            t: boolean;
            getTree(): SchemaLiteral;
        };
        optional(rules?: Rule[]): {
            t?: boolean;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Signature to define a number or optional number type
     */
    export interface NumberType {
        (rules?: Rule[]): {
            t: number;
            getTree(): SchemaLiteral;
        };
        optional(rules?: Rule[]): {
            t?: number;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Signature to define an object with members or an optional object
     * with members.
     */
    export interface ObjectType {
        (rules?: Rule[]): {
            members<T extends TypedSchema>(schema: T): {
                t: {
                    [P in keyof T]: T[P]['t'];
                };
                getTree(): SchemaObject;
            };
        };
        optional(rules?: Rule[]): {
            members<T extends TypedSchema>(schema: T): {
                t?: {
                    [P in keyof T]: T[P]['t'];
                };
                getTree(): SchemaObject;
            };
        };
    }
    /**
     * Signature to define an array with members or an optional array
     * with members or array/optional array with optional members
     */
    export interface ArrayType {
        (rules?: Rule[]): {
            members<T extends {
                t?: any;
                getTree(): SchemaLiteral | SchemaObject | SchemaArray;
            }>(schema: T): {
                t: T['t'][];
                getTree(): SchemaArray;
            };
            anyMembers(): {
                t: any[];
                getTree(): SchemaArray;
            };
        };
        optional(rules?: Rule[]): {
            members<T extends {
                t?: any;
                getTree(): SchemaLiteral | SchemaObject | SchemaArray;
            }>(schema: T): {
                t?: T['t'][];
                getTree(): SchemaArray;
            };
            anyMembers(): {
                t?: any[];
                getTree(): SchemaArray;
            };
        };
    }
    /**
     * Options accepted by the enum type
     */
    export type AllowedEnumOptions = SchemaRef<unknown> | readonly unknown[];
    /**
     * Conditionally finds the return value for the Enum options
     */
    export type EnumReturnValue<Options extends AllowedEnumOptions> = Options extends SchemaRef<infer R> ? R extends readonly unknown[] ? R[number] : unknown : Options extends readonly unknown[] ? Options[number] : never;
    /**
     * Conditionally finds the return value for the EnumSet options
     */
    export type EnumSetReturnValue<Options extends AllowedEnumOptions> = Options extends SchemaRef<infer R> ? R extends readonly unknown[] ? R[number][] : unknown : Options extends readonly unknown[] ? Options[number][] : never;
    /**
     * Signature to define an enum type. We accept a static list of enum
     * values or a ref that is resolved lazily.
     */
    export interface EnumType {
        <Options extends AllowedEnumOptions>(options: Options, rules?: Rule[]): {
            t: EnumReturnValue<Options>;
            getTree(): SchemaLiteral;
        };
        optional<Options extends AllowedEnumOptions>(options: Options, rules?: Rule[]): {
            t?: EnumReturnValue<Options>;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Signature to define an enum set type
     */
    export interface EnumSetType {
        <Options extends AllowedEnumOptions>(options: Options, rules?: Rule[]): {
            t: EnumSetReturnValue<Options>;
            getTree(): SchemaLiteral;
        };
        optional<Options extends AllowedEnumOptions>(options: Options, rules?: Rule[]): {
            t?: EnumSetReturnValue<Options>;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Type for validating multipart files
     */
    export interface FileType {
        (options?: Partial<FileValidationOptions>, rules?: Rule[]): {
            t: MultipartFileContract;
            getTree(): SchemaLiteral;
        };
        optional(options?: Partial<FileValidationOptions>, rules?: Rule[]): {
            t?: MultipartFileContract;
            getTree(): SchemaLiteral;
        };
    }
    /**
     * Shape of `schema.create` output
     */
    export type ParsedTypedSchema<T extends TypedSchema> = {
        props: {
            [P in keyof T]: T[P]['t'];
        };
        tree: ParsedSchemaTree;
    };
    /**
     * List of schema methods available to define a schema
     */
    export interface Schema {
        string: StringType;
        boolean: BooleanType;
        number: NumberType;
        date: DateType;
        enum: EnumType;
        enumSet: EnumSetType;
        object: ObjectType;
        array: ArrayType;
        file: FileType;
        refs: <T extends Object>(refs: T) => {
            [K in keyof T]: SchemaRef<T[K]>;
        };
        create<T extends TypedSchema>(schema: T): ParsedTypedSchema<T>;
    }
    /**
     * Shape of validator config
     */
    export type ValidatorConfig = {
        bail: boolean;
        reporter: ErrorReporterConstructorContract;
    };
    /**
     * The validator node object accepted by the validated
     * method
     */
    export type ValidatorNode<T extends ParsedTypedSchema<TypedSchema>> = {
        schema: T;
        data: any;
        refs?: {
            [key: string]: SchemaRef<unknown>;
        };
        cacheKey?: string;
        messages?: CustomMessages;
        existsStrict?: boolean;
        reporter?: ErrorReporterConstructorContract;
        bail?: boolean;
    };
    /**
     * Shape of validator accepted by the request.validate function. It can be
     * a class with constructor that accepts the Context or a plain object
     * with properties accepted by the `validator.validate` method.
     */
    export type RequestValidatorNode<T extends ParsedTypedSchema<TypedSchema>> = (new (ctx: HttpContextContract) => WithOptional<ValidatorNode<T>, 'data'>) | WithOptional<ValidatorNode<T>, 'data'>;
    /**
     * Shape of the function that validates the compiler output
     */
    export type ValidateFn = <T extends ParsedTypedSchema<TypedSchema>>(validator: ValidatorNode<T>) => Promise<T['props']>;
    /**
     * Email validation and sanitization options
     */
    export type EmailRuleOptions = {
        domainSpecificValidation?: boolean;
        allowIpDomain?: boolean;
        ignoreMaxLength?: boolean;
        sanitize?: boolean | {
            lowerCase: boolean;
        };
    };
    /**
     * List of available validation rules. The rules are not the validation
     * implementations, but instead a pointer to the validation implementation
     * by it's name.
     *
     * Do not add primitives here, since they are covered by the types. For example
     * schema.string will add rules.string automatically.
     */
    export interface Rules {
        /**
         * Field under validation must always exists
         */
        required(): Rule;
        /**
         * Field under validation must always exists if the
         * target field exists
         */
        requiredIfExists(field: string): Rule;
        /**
         * Field under validation must always exists, if all of the
         * target field exists
         */
        requiredIfExistsAll(field: string[]): Rule;
        /**
         * Field under validation must always exists, if any of the
         * target fields exists
         */
        requiredIfExistsAny(field: string[]): Rule;
        /**
         * Field under validation must always exists, if target field
         * does not exists
         */
        requiredIfNotExists(field: string): Rule;
        /**
         * Field under validation must always exists, if all of the
         * target fields does not exists
         */
        requiredIfNotExistsAll(field: string[]): Rule;
        /**
         * Field under validation must always exists, if any of the
         * target fields does not exists
         */
        requiredIfNotExistsAny(field: string[]): Rule;
        /**
         * Field under validation must always exists, when the defined
         * expecations are met
         */
        requiredWhen(field: string, operator: 'in' | 'notIn', comparisonValues: any[] | SchemaRef<any[]>): Rule;
        requiredWhen(field: string, operator: '>' | '<' | '>=' | '<=', comparisonValues: number | SchemaRef<number>): Rule;
        requiredWhen(field: string, operator: 'in' | 'notIn' | '=' | '!=' | '>' | '<' | '>=' | '<=', comparisonValues: any | SchemaRef<any>): Rule;
        /**
         * Number must be unsigned
         */
        unsigned(): Rule;
        /**
         * String must be alpha
         */
        alpha(options?: {
            allow?: ('space' | 'underscore' | 'dash')[];
        }): Rule;
        /**
         * String must match regex
         */
        regex(regexPattern: RegExp): Rule;
        email(options?: EmailRuleOptions): Rule;
        ip(options?: {
            version?: '4' | 4 | 6 | '6';
        }): Rule;
        uuid(options?: {
            version?: UUIDVersion;
        }): Rule;
        mobile(options?: {
            strict?: boolean;
            locales?: validatorJs.MobilePhoneLocale[];
        }): Rule;
        /**
         * String or array must have defined maximum length
         */
        maxLength(length: number): Rule;
        minLength(length: number): Rule;
        /**
         * Confirm field to be exists and have the same value
         */
        confirmed(): Rule;
        distinct(field: string): Rule;
    }
    /**
     * Shape of schema module
     */
    const schema: Schema;
    /**
     * Shape of rules module
     */
    const rules: Rules;
    /**
     * Shape of validator module
     */
    const validator: {
        /**
         * Validate is a shorthand to compile + exec. If cache
         * key is defined, then it will also cache the
         * schemas.
         */
        validate: ValidateFn;
        /**
         * Add a new validation rule
         */
        addRule(name: string, ruleDefinition: ValidationContract<any>): void;
        /**
         * Add a new validation rule
         */
        rule<Options extends any>(name: string, validateFn: ValidationContract<Options>['validate'], compileFn?: (options: any[], type: NodeType, subtype: NodeSubType) => Partial<ParsedRule<Options>>, restrictForTypes?: NodeSubType[]): void;
        /**
         * Type definition is set to any, since one can pass in a function or
         * an object that has chainable API. So there is no simple way
         * to guard the type definition. However, the `schema.create`
         * method will fail if the final outcome doesn't have `getTree`
         * method on it.
         */
        addType(name: string, typeDefinition: any): void;
        /**
         * Type definition is set to any, since one can pass in a function or
         * an object that has chainable API. So there is no simple way
         * to guard the type definition. However, the `schema.create`
         * method will fail if the final outcome doesn't have `getTree`
         * method on it.
         */
        type(name: string, typeDefinition: any): void;
        /**
         * Helpers required by the custom rules
         */
        helpers: {
            getFieldValue: (field: string, root: any, tip: any) => any;
            exists: (value: any) => boolean;
            isRef(value: any): value is SchemaRef<unknown>;
            existsStrict: (value: any) => boolean;
        };
        /**
         * List of bundled reporters
         */
        reporters: {
            api: ErrorReporterConstructorContract<{
                errors: ApiErrorNode[];
            }>;
            jsonapi: ErrorReporterConstructorContract<{
                errors: JsonApiErrorNode[];
            }>;
            vanilla: ErrorReporterConstructorContract<VanillaErrorNode>;
        };
    };
    export { schema, rules, validator };
}

i tried updating the node modules with npm update, deleted my node_modules and installed them back but in vain.

Any suggestions?

[fnoquiq]

You should only update @adonisjs/core, so the validator will be updated automatically.

Update @adonisjs/core from 5.0.0-preview-rc-1.9 to 5.0.0-preview-rc-1.11.

The validator has been updated on this commit.

[popovicieduard]

Thank you