@types/hapi__joi

  • Version 17.1.7
  • Published
  • 86.2 kB
  • No dependencies
  • MIT license

Install

npm i @types/hapi__joi
yarn add @types/hapi__joi
pnpm add @types/hapi__joi

Overview

TypeScript definitions for @hapi/joi

Index

Variables

Interfaces

Type Aliases

Variables

variable Joi

const Joi: Joi.Root;

    Interfaces

    interface AddRuleOptions

    interface AddRuleOptions {}

      property args

      args?:
      | {
      [key: string]: any;
      }
      | undefined;

        property name

        name: string;

          interface AlternativesSchema

          interface AlternativesSchema extends AnySchema {}

            method conditional

            conditional: {
            (ref: string | Reference, options: WhenOptions): this;
            (ref: Schema, options: WhenSchemaOptions): this;
            };
            • Adds a conditional alternative schema type, either based on another key value, or a schema peeking into the current value.

            method match

            match: (mode: 'any' | 'all' | 'one') => this;
            • Requires the validated value to match a specific set of the provided alternative.try() schemas. Cannot be combined with alternatives.conditional().

            method try

            try: (...types: SchemaLike[]) => this;
            • Adds an alternative schema type for attempting to match against the validated value.

            interface AnySchema

            interface AnySchema extends SchemaInternals {}

              property $

              $: this;
              • Starts a ruleset in order to apply multiple rule options. The set ends when rule(), keep(), message(), or warn() is called.

              property ruleset

              ruleset: this;
              • Starts a ruleset in order to apply multiple rule options. The set ends when rule(), keep(), message(), or warn() is called.

              property type

              type?: Types | string | undefined;

                method allow

                allow: (...values: any[]) => this;
                • Whitelists a value

                method alter

                alter: (targets: Record<string, SchemaFunction>) => this;
                • Assign target alteration options to a schema that are applied when any.tailor() is called.

                  Parameter targets

                  an object where each key is a target name, and each value is a function that takes an schema and returns an schema.

                method bind

                bind: () => this;
                • By default, some Joi methods to function properly need to rely on the Joi instance they are attached to because they use this internally. So Joi.string() works but if you extract the function from it and call string() it won't. bind() creates a new Joi instance where all the functions relying on this are bound to the Joi instance.

                method cache

                cache: (cache?: Cache) => this;
                • Adds caching to the schema which will attempt to cache the validation results (success and failures) of incoming inputs. If no cache is passed, a default cache is provisioned by using cache.provision() internally.

                method cast

                cast: (to: 'map' | 'number' | 'set' | 'string') => this;
                • Casts the validated value to the specified type.

                method concat

                concat: (schema: this) => this;
                • Returns a new type that is the result of adding the rules of one type to another.

                method custom

                custom: (fn: CustomValidator, description?: string) => this;
                • Adds a custom validation function.

                method default

                default: (
                value?:
                | BasicType
                | Reference
                | ((parent: any, helpers: CustomHelpers) => BasicType | Reference)
                ) => this;
                • Sets a default value if the original value is undefined where:

                  Parameter value

                  the default value. One of: - a literal value (string, number, object, etc.) - a [references](#refkey-options) - a function which returns the default value using the signature function(parent, helpers) where: - parent - a clone of the object containing the value being validated. Note that since specifying a parent ragument performs cloning, do not declare format arguments if you are not using them. - helpers - same as thsoe described in [any.custom()](anycustomermethod_description)

                  When called without any value on an object schema type, a default value will be automatically generated based on the default values of the object keys.

                  Note that if value is an object, any changes to the object after default() is called will change the reference and any future assignment.

                method describe

                describe: () => Description;
                • Returns a plain object representing the schema's rules and properties

                method description

                description: (desc: string) => this;
                • Annotates the key

                method disallow

                disallow: (...values: any[]) => this;
                • Disallows values.

                method empty

                empty: (schema?: SchemaLike) => this;
                • Considers anything that matches the schema to be empty (undefined).

                  Parameter schema

                  any object or joi schema to match. An undefined schema unsets that rule.

                method equal

                equal: (...values: any[]) => this;
                • Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.

                method error

                error: (err: Error | ValidationErrorFunction) => this;
                • Overrides the default joi error with a custom error if the rule fails where:

                  Parameter err

                  can be: an instance of Error - the override error. a function(errors), taking an array of errors as argument, where it must either: return a string - substitutes the error message with this text return a single object or an Array of it, where: type - optional parameter providing the type of the error (eg. number.min). message - optional parameter if template is provided, containing the text of the error. template - optional parameter if message is provided, containing a template string, using the same format as usual joi language errors. context - optional parameter, to provide context to your error if you are using the template. return an Error - same as when you directly provide an Error, but you can customize the error message based on the errors.

                  Note that if you provide an Error, it will be returned as-is, unmodified and undecorated with any of the normal joi error properties. If validation fails and another error is found before the error override, that error will be returned and the override will be ignored (unless the abortEarly option has been set to false).

                method example

                example: (value: any, options?: { override: boolean }) => this;
                • Annotates the key with an example value, must be valid.

                method exist

                exist: () => this;
                • Marks a key as required which will not allow undefined as value. All keys are optional by default.

                method external

                external: (method: ExternalValidationFunction, description?: string) => this;
                • Adds an external validation rule.

                  Note that external validation rules are only called after the all other validation rules for the entire schema (from the value root) are checked. This means that any changes made to the value by the external rules are not available to any other validation rules during the non-external validation phase. If schema validation failed, no external validation rules are called.

                method extract

                extract: (path: string | string[]) => Schema;
                • Returns a sub-schema based on a path of object keys or schema ids.

                  Parameter path

                  a dot . separated path string or a pre-split array of path keys. The keys must match the sub-schema id or object key (if no id was explicitly set).

                method failover

                failover: (value: any) => this;
                • Sets a failover value if the original value fails passing validation.

                  Parameter value

                  the failover value. value supports references. value may be assigned a function which returns the default value.

                  If value is specified as a function that accepts a single parameter, that parameter will be a context object that can be used to derive the resulting value. Note that if value is an object, any changes to the object after failover() is called will change the reference and any future assignment. Use a function when setting a dynamic value (e.g. the current time). Using a function with a single argument performs some internal cloning which has a performance impact. If you do not need access to the context, define the function without any arguments.

                method forbidden

                forbidden: () => this;
                • Marks a key as forbidden which will not allow any value except undefined. Used to explicitly forbid keys.

                method fork

                fork: (key: string | string[] | string[][], adjuster: SchemaFunction) => this;
                • Returns a new schema where each of the path keys listed have been modified.

                  Parameter key

                  an array of key strings, a single key string, or an array of arrays of pre-split key strings.

                  Parameter adjuster

                  a function which must return a modified schema.

                method id

                id: (name?: string) => this;
                • Sets a schema id for reaching into the schema via any.extract(). If no id is set, the schema id defaults to the object key it is associated with. If the schema is used in an array or alternatives type and no id is set, the schema in unreachable.

                method invalid

                invalid: (...values: any[]) => this;
                • Disallows values.

                method keep

                keep: () => this;
                • Same as rule({ keep: true }).

                  Note that keep() will terminate the current ruleset and cannot be followed by another rule option. Use rule() to apply multiple rule options.

                method label

                label: (name: string) => this;
                • Overrides the key name in error messages.

                method message

                message: (message: string) => this;
                • Same as rule({ message }).

                  Note that message() will terminate the current ruleset and cannot be followed by another rule option. Use rule() to apply multiple rule options.

                method messages

                messages: (messages: LanguageMessages) => this;
                • Same as any.prefs({ messages }). Note that while any.message() applies only to the last rule or ruleset, any.messages() applies to the entire schema.

                method meta

                meta: (meta: object) => this;
                • Attaches metadata to the key.

                method not

                not: (...values: any[]) => this;
                • Disallows values.

                method note

                note: (...notes: string[]) => this;
                • Annotates the key

                method only

                only: () => this;
                • Requires the validated value to match of the provided any.allow() values. It has not effect when called together with any.valid() since it already sets the requirements. When used with any.allow() it converts it to an any.valid().

                method optional

                optional: () => this;
                • Marks a key as optional which will allow undefined as values. Used to annotate the schema for readability as all keys are optional by default.

                method options

                options: (options: ValidationOptions) => this;
                • Overrides the global validate() options for the current key and any sub-key.

                method preferences

                preferences: (options: ValidationOptions) => this;
                • Overrides the global validate() options for the current key and any sub-key.

                method prefs

                prefs: (options: ValidationOptions) => this;
                • Overrides the global validate() options for the current key and any sub-key.

                method presence

                presence: (mode: PresenceMode) => this;
                • Sets the presence mode for the schema.

                method raw

                raw: (enabled?: boolean) => this;
                • Outputs the original untouched value instead of the casted value.

                method required

                required: () => this;
                • Marks a key as required which will not allow undefined as value. All keys are optional by default.

                method rule

                rule: (options: RuleOptions) => this;
                • Applies a set of rule options to the current ruleset or last rule added.

                  When applying rule options, the last rule (e.g. min()) is used unless there is an active ruleset defined (e.g. $.min().max()) in which case the options are applied to all the provided rules. Once rule() is called, the previous rules can no longer be modified and any active ruleset is terminated.

                  Rule modifications can only be applied to supported rules. Most of the any methods do not support rule modifications because they are implemented using schema flags (e.g. required()) or special internal implementation (e.g. valid()). In those cases, use the any.messages() method to override the error codes for the errors you want to customize.

                method shared

                shared: (ref: Schema) => this;
                • Registers a schema to be used by decendents of the current schema in named link references.

                method strict

                strict: (isStrict?: boolean) => this;
                • Sets the options.convert options to false which prevent type casting for the current key and any child keys.

                method strip

                strip: (enabled?: boolean) => this;
                • Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.

                  Parameter enabled

                  if true, the value is stripped, otherwise the validated value is retained. Defaults to true.

                method tag

                tag: (...tags: string[]) => this;
                • Annotates the key

                method tailor

                tailor: (targets: string | string[]) => Schema;
                • Applies any assigned target alterations to a copy of the schema that were applied via any.alter().

                method unit

                unit: (name: string) => this;
                • Annotates the key with a unit name.

                method valid

                valid: (...values: any[]) => this;
                • Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.

                method validate

                validate: (value: any, options?: ValidationOptions) => ValidationResult;
                • Validates a value using the schema and options.

                method validateAsync

                validateAsync: (value: any, options?: AsyncValidationOptions) => Promise<any>;
                • Validates a value using the schema and options.

                method warn

                warn: () => this;
                • Same as rule({ warn: true }). Note that warn() will terminate the current ruleset and cannot be followed by another rule option. Use rule() to apply multiple rule options.

                method warning

                warning: (code: string, context: Context) => this;
                • Generates a warning. When calling any.validateAsync(), set the warning option to true to enable warnings. Warnings are reported separately from errors alongside the result value via the warning key (i.e. { value, warning }). Warning are always included when calling any.validate().

                method when

                when: {
                (ref: string | Reference, options: WhenOptions): this;
                (ref: Schema, options: WhenSchemaOptions): this;
                };
                • Converts the type into an alternatives type where the conditions are merged into the type definition where:

                interface ArraySchema

                interface ArraySchema extends AnySchema {}

                  method has

                  has: (schema: SchemaLike) => this;
                  • Verifies that an assertion passes for at least one item in the array, where: schema - the validation rules required to satisfy the assertion. If the schema includes references, they are resolved against the array item being tested, not the value of the ref target.

                  method items

                  items: (...types: SchemaLike[]) => this;
                  • List the types allowed for the array values. If a given type is .required() then there must be a matching item in the array. If a type is .forbidden() then it cannot appear in the array. Required items can be added multiple times to signify that multiple items must be found. Errors will contain the number of items that didn't match. Any unmatched item having a label will be mentioned explicitly.

                    Parameter type

                    a joi schema object to validate each array item against.

                  method length

                  length: (limit: number | Reference) => this;
                  • Specifies the exact number of items in the array.

                  method max

                  max: (limit: number | Reference) => this;
                  • Specifies the maximum number of items in the array.

                  method min

                  min: (limit: number | Reference) => this;
                  • Specifies the minimum number of items in the array.

                  method ordered

                  ordered: (...types: SchemaLike[]) => this;
                  • Lists the types in sequence order for the array values where:

                    Parameter type

                    a joi schema object to validate against each array item in sequence order. type can be multiple values passed as individual arguments. If a given type is .required() then there must be a matching item with the same index position in the array. Errors will contain the number of items that didn't match. Any unmatched item having a label will be mentioned explicitly.

                  method single

                  single: (enabled?: any) => this;
                  • Allow single values to be checked against rules as if it were provided as an array. enabled can be used with a falsy value to go back to the default behavior.

                  method sort

                  sort: (options?: ArraySortOptions) => this;
                  • Sorts the array by given order.

                  method sparse

                  sparse: (enabled?: any) => this;
                  • Allow this array to be sparse. enabled can be used with a falsy value to go back to the default behavior.

                  method unique

                  unique: (
                  comparator?: string | ComparatorFunction,
                  options?: ArrayUniqueOptions
                  ) => this;
                  • Requires the array values to be unique. Remember that if you provide a custom comparator function, different types can be passed as parameter depending on the rules you set on items. Be aware that a deep equality is performed on elements of the array having a type of object, a performance penalty is to be expected for this kind of operation.

                  interface ArraySortOptions

                  interface ArraySortOptions {}

                    property by

                    by?: string | Reference | undefined;

                      property order

                      order?: 'ascending' | 'descending' | undefined;
                      • 'ascending'

                      interface ArrayUniqueOptions

                      interface ArrayUniqueOptions extends HierarchySeparatorOptions {}

                        property ignoreUndefined

                        ignoreUndefined?: boolean | undefined;
                        • if true, undefined values for the dot notation string comparator will not cause the array to fail on uniqueness.

                          false

                        interface AsyncValidationOptions

                        interface AsyncValidationOptions extends ValidationOptions {}

                          property warnings

                          warnings?: boolean | undefined;
                          • when true, warnings are returned alongside the value (i.e. { value, warning }).

                            false

                          interface Base64Options

                          interface Base64Options extends Pick<DataUriOptions, 'paddingRequired'> {}

                            property urlSafe

                            urlSafe?: boolean | undefined;
                            • if true, uses the URI-safe base64 format which replaces + with - and \ with _.

                              false

                            interface BaseValidationOptions

                            interface BaseValidationOptions {}

                              property abortEarly

                              abortEarly?: boolean | undefined;
                              • when true, stops validation on the first error, otherwise returns all the errors found.

                                true

                              property allowUnknown

                              allowUnknown?: boolean | undefined;
                              • when true, allows object to contain unknown keys which are ignored.

                                false

                              property cache

                              cache?: boolean | undefined;
                              • when true, schema caching is enabled (for schemas with explicit caching rules).

                                false

                              property context

                              context?: Context | undefined;
                              • provides an external data set to be used in references

                              property convert

                              convert?: boolean | undefined;
                              • when true, attempts to cast values to the required types (e.g. a string to a number).

                                true

                              property dateFormat

                              dateFormat?: 'date' | 'iso' | 'string' | 'time' | 'utc' | undefined;
                              • sets the string format used when converting dates to strings in error messages and casting.

                                'iso'

                              property debug

                              debug?: boolean | undefined;
                              • when true, valid results and throw errors are decorated with a debug property which includes an array of the validation steps used to generate the returned result.

                                false

                              property errors

                              errors?: ErrorFormattingOptions | undefined;
                              • error formatting settings.

                              property externals

                              externals?: boolean | undefined;
                              • if false, the external rules set with any.external() are ignored, which is required to ignore any external validations in synchronous mode (or an exception is thrown).

                                true

                              property noDefaults

                              noDefaults?: boolean | undefined;
                              • when true, do not apply default values.

                                false

                              property nonEnumerables

                              nonEnumerables?: boolean | undefined;
                              • when true, inputs are shallow cloned to include non-enumerables properties.

                                false

                              property presence

                              presence?: PresenceMode | undefined;
                              • sets the default presence requirements. Supported modes: 'optional', 'required', and 'forbidden'.

                                'optional'

                              property skipFunctions

                              skipFunctions?: boolean | undefined;
                              • when true, ignores unknown keys with a function value.

                                false

                              property stripUnknown

                              stripUnknown?:
                              | boolean
                              | { arrays?: boolean | undefined; objects?: boolean | undefined }
                              | undefined;
                              • remove unknown elements from objects and arrays. - when true, all unknown elements will be removed - when an object: - objects - set to true to remove unknown keys from objects

                                false

                              interface BinarySchema

                              interface BinarySchema extends AnySchema {}

                                method encoding

                                encoding: (encoding: string) => this;
                                • Sets the string encoding format if a string input is converted to a buffer.

                                method length

                                length: (limit: number | Reference) => this;
                                • Specifies the exact length of the buffer:

                                method max

                                max: (limit: number | Reference) => this;
                                • Specifies the maximum length of the buffer.

                                method min

                                min: (limit: number | Reference) => this;
                                • Specifies the minimum length of the buffer.

                                interface BooleanSchema

                                interface BooleanSchema extends AnySchema {}

                                  method falsy

                                  falsy: (...values: Array<string | number>) => this;
                                  • Allows for additional values to be considered valid booleans by converting them to false during validation. String comparisons are by default case insensitive, see boolean.sensitive() to change this behavior.

                                    Parameter values

                                    strings, numbers or arrays of them

                                  method sensitive

                                  sensitive: (enabled?: boolean) => this;
                                  • Allows the values provided to truthy and falsy as well as the "true" and "false" default conversion (when not in strict() mode) to be matched in a case insensitive manner.

                                  method truthy

                                  truthy: (...values: Array<string | number>) => this;
                                  • Allows for additional values to be considered valid booleans by converting them to true during validation. String comparisons are by default case insensitive, see boolean.sensitive() to change this behavior.

                                    Parameter values

                                    strings, numbers or arrays of them

                                  interface Cache

                                  interface Cache {}

                                    method get

                                    get: (key: any) => any;
                                    • Retrieve an item from the cache.

                                      Note that key and value can be anything including objects, array, etc.

                                    method set

                                    set: (key: any, value: any) => void;
                                    • Add an item to the cache.

                                      Note that key and value can be anything including objects, array, etc.

                                    interface CacheConfiguration

                                    interface CacheConfiguration {}

                                      method provision

                                      provision: (options?: CacheProvisionOptions) => void;
                                      • Provisions a simple LRU cache for caching simple inputs (undefined, null, strings, numbers, and booleans).

                                      interface CacheProvisionOptions

                                      interface CacheProvisionOptions {}

                                        property max

                                        max: number;
                                        • number of items to store in the cache before the least used items are dropped.

                                          1000

                                        interface CoerceObject

                                        interface CoerceObject {}

                                          property from

                                          from?: string | string[] | undefined;

                                            property method

                                            method: CoerceFunction;

                                              interface CoerceResult

                                              interface CoerceResult {}

                                                property errors

                                                errors?: ErrorReport[] | undefined;

                                                  property value

                                                  value?: any;

                                                    interface CompileOptions

                                                    interface CompileOptions {}

                                                      property legacy

                                                      legacy: boolean;
                                                      • If true and the provided schema is (or contains parts) using an older version of joi, will return a compiled schema that is compatible with the older version. If false, the schema is always compiled using the current version and if older schema components are found, an error is thrown.

                                                      interface Context

                                                      interface Context {}

                                                        property key

                                                        key?: string | undefined;

                                                          property label

                                                          label?: string | undefined;

                                                            property value

                                                            value?: any;

                                                              index signature

                                                              [key: string]: any;

                                                                interface CreateErrorOptions

                                                                interface CreateErrorOptions {}

                                                                  property flags

                                                                  flags?: boolean | undefined;

                                                                    property messages

                                                                    messages?: LanguageMessages | undefined;

                                                                      interface CustomHelpers

                                                                      interface CustomHelpers<V = any> {}

                                                                        property error

                                                                        error: (code: string, local?: Context) => ErrorReport;

                                                                          property message

                                                                          message: (messages: LanguageMessages, local?: Context) => ErrorReport;

                                                                            property original

                                                                            original: V;

                                                                              property prefs

                                                                              prefs: ValidationOptions;

                                                                                property schema

                                                                                schema: ExtensionBoundSchema;

                                                                                  property state

                                                                                  state: State;

                                                                                    property warn

                                                                                    warn: (code: string, local?: Context) => void;

                                                                                      interface DataUriOptions

                                                                                      interface DataUriOptions {}

                                                                                        property paddingRequired

                                                                                        paddingRequired?: boolean | undefined;
                                                                                        • optional parameter defaulting to true which will require = padding if true or make padding optional if false

                                                                                          true

                                                                                        interface DateSchema

                                                                                        interface DateSchema extends AnySchema {}

                                                                                          method greater

                                                                                          greater: (date: 'now' | Date | number | string | Reference) => this;
                                                                                          • Specifies that the value must be greater than date. Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future. It can also be a reference to another field.

                                                                                          method iso

                                                                                          iso: () => this;
                                                                                          • Requires the string value to be in valid ISO 8601 date format.

                                                                                          method less

                                                                                          less: (date: 'now' | Date | number | string | Reference) => this;
                                                                                          • Specifies that the value must be less than date. Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future. It can also be a reference to another field.

                                                                                          method max

                                                                                          max: (date: 'now' | Date | number | string | Reference) => this;
                                                                                          • Specifies the latest date allowed. Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future. It can also be a reference to another field.

                                                                                          method min

                                                                                          min: (date: 'now' | Date | number | string | Reference) => this;
                                                                                          • Specifies the oldest date allowed. Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future. It can also be a reference to another field.

                                                                                          method timestamp

                                                                                          timestamp: (type?: 'javascript' | 'unix') => this;
                                                                                          • Requires the value to be a timestamp interval from Unix Time.

                                                                                            Parameter type

                                                                                            the type of timestamp (allowed values are unix or javascript [default])

                                                                                          interface Description

                                                                                          interface Description {}

                                                                                            property description

                                                                                            description?: string | undefined;

                                                                                              property example

                                                                                              example?: any[] | undefined;

                                                                                                property flags

                                                                                                flags?: object | undefined;

                                                                                                  property invalids

                                                                                                  invalids?: any[] | undefined;

                                                                                                    property label

                                                                                                    label?: string | undefined;

                                                                                                      property meta

                                                                                                      meta?: any[] | undefined;

                                                                                                        property notes

                                                                                                        notes?: string[] | undefined;

                                                                                                          property options

                                                                                                          options?: ValidationOptions | undefined;

                                                                                                            property tags

                                                                                                            tags?: string[] | undefined;

                                                                                                              property type

                                                                                                              type?: Types | string | undefined;

                                                                                                                property unit

                                                                                                                unit?: string | undefined;

                                                                                                                  property valids

                                                                                                                  valids?: any[] | undefined;

                                                                                                                    index signature

                                                                                                                    [key: string]: any;

                                                                                                                      interface DomainOptions

                                                                                                                      interface DomainOptions {}

                                                                                                                        property allowUnicode

                                                                                                                        allowUnicode?: boolean | undefined;
                                                                                                                        • If true, Unicode characters are permitted

                                                                                                                          true

                                                                                                                        property minDomainSegments

                                                                                                                        minDomainSegments?: number | undefined;
                                                                                                                        • Number of segments required for the domain.

                                                                                                                          2

                                                                                                                        property tlds

                                                                                                                        tlds?: TopLevelDomainOptions | false | undefined;
                                                                                                                        • Options for TLD (top level domain) validation. By default, the TLD must be a valid name listed on the [IANA registry](http://data.iana.org/TLD/tlds-alpha-by-domain.txt)

                                                                                                                          { allow: true }

                                                                                                                        interface EmailOptions

                                                                                                                        interface EmailOptions {}

                                                                                                                          property allowUnicode

                                                                                                                          allowUnicode?: boolean | undefined;
                                                                                                                          • If true, Unicode characters are permitted

                                                                                                                            true

                                                                                                                          property ignoreLength

                                                                                                                          ignoreLength?: boolean | undefined;
                                                                                                                          • if true, ignore invalid email length errors.

                                                                                                                            false

                                                                                                                          property minDomainSegments

                                                                                                                          minDomainSegments?: number | undefined;
                                                                                                                          • Number of segments required for the domain. Be careful since some domains, such as io, directly allow email.

                                                                                                                            2

                                                                                                                          property multiple

                                                                                                                          multiple?: boolean | undefined;
                                                                                                                          • if true, allows multiple email addresses in a single string, separated by , or the separator characters.

                                                                                                                            false

                                                                                                                          property separator

                                                                                                                          separator?: string | string[] | undefined;
                                                                                                                          • when multiple is true, overrides the default , separator. String can be a single character or multiple separator characters.

                                                                                                                            ','

                                                                                                                          property tlds

                                                                                                                          tlds?: TopLevelDomainOptions | false | undefined;
                                                                                                                          • Options for TLD (top level domain) validation. By default, the TLD must be a valid name listed on the [IANA registry](http://data.iana.org/TLD/tlds-alpha-by-domain.txt)

                                                                                                                            { allow: true }

                                                                                                                          interface Err

                                                                                                                          interface Err {}

                                                                                                                            method toString

                                                                                                                            toString: () => string;

                                                                                                                              interface ErrorFormattingOptions

                                                                                                                              interface ErrorFormattingOptions {}

                                                                                                                                property escapeHtml

                                                                                                                                escapeHtml?: boolean | undefined;
                                                                                                                                • when true, error message templates will escape special characters to HTML entities, for security purposes.

                                                                                                                                  false

                                                                                                                                property label

                                                                                                                                label?: 'path' | 'key' | false | undefined;
                                                                                                                                • defines the value used to set the label context variable.

                                                                                                                                property language

                                                                                                                                language?: keyof LanguageMessages | undefined;
                                                                                                                                • The preferred language code for error messages. The value is matched against keys at the root of the messages object, and then the error code as a child key of that. Can be a reference to the value, global context, or local context which is the root value passed to the validation function.

                                                                                                                                  Note that references to the value are usually not what you want as they move around the value structure relative to where the error happens. Instead, either use the global context, or the absolute value (e.g. Joi.ref('/variable'))

                                                                                                                                property render

                                                                                                                                render?: boolean | undefined;
                                                                                                                                • when false, skips rendering error templates. Useful when error messages are generated elsewhere to save processing time.

                                                                                                                                  true

                                                                                                                                property stack

                                                                                                                                stack?: boolean | undefined;
                                                                                                                                • when true, the main error will possess a stack trace, otherwise it will be disabled. Defaults to false for performances reasons. Has no effect on platforms other than V8/node.js as it uses the Stack trace API.

                                                                                                                                  false

                                                                                                                                property wrap

                                                                                                                                wrap?:
                                                                                                                                | {
                                                                                                                                /**
                                                                                                                                * the characters used around `{#label}` references. Defaults to `'"'`.
                                                                                                                                *
                                                                                                                                * @default '"'
                                                                                                                                */
                                                                                                                                label?: string | false | undefined;
                                                                                                                                /**
                                                                                                                                * the characters used around array avlues. Defaults to `'[]'`
                                                                                                                                *
                                                                                                                                * @default '[]'
                                                                                                                                */
                                                                                                                                array?: string | false | undefined;
                                                                                                                                }
                                                                                                                                | undefined;
                                                                                                                                • overrides the way values are wrapped (e.g. [] arround arrays, "" around labels). Each key can be set to a string with one (same character before and after the value) or two characters (first character before and second character after), or false to disable wrapping.

                                                                                                                                interface ErrorReport

                                                                                                                                interface ErrorReport extends Error {}

                                                                                                                                  property code

                                                                                                                                  code: string;

                                                                                                                                    property flags

                                                                                                                                    flags: Record<string, ExtensionFlag>;

                                                                                                                                      property messages

                                                                                                                                      messages: LanguageMessages;

                                                                                                                                        property path

                                                                                                                                        path: string[];

                                                                                                                                          property prefs

                                                                                                                                          prefs: ErrorValidationOptions;

                                                                                                                                            property state

                                                                                                                                            state: State;

                                                                                                                                              property value

                                                                                                                                              value: any;

                                                                                                                                                interface ErrorValidationOptions

                                                                                                                                                interface ErrorValidationOptions extends BaseValidationOptions {}

                                                                                                                                                  property messages

                                                                                                                                                  messages?: Record<string, LanguageMessageTemplate> | undefined;

                                                                                                                                                    interface Extension

                                                                                                                                                    interface Extension {}

                                                                                                                                                      property base

                                                                                                                                                      base?: Schema | undefined;

                                                                                                                                                        property cast

                                                                                                                                                        cast?:
                                                                                                                                                        | Record<
                                                                                                                                                        string,
                                                                                                                                                        { from(value: any): any; to(value: any, helpers: CustomHelpers): any }
                                                                                                                                                        >
                                                                                                                                                        | undefined;
                                                                                                                                                        • undocumented options

                                                                                                                                                        property coerce

                                                                                                                                                        coerce?: CoerceFunction | CoerceObject | undefined;

                                                                                                                                                          property flags

                                                                                                                                                          flags?: Record<string, ExtensionFlag> | undefined;

                                                                                                                                                            property manifest

                                                                                                                                                            manifest?:
                                                                                                                                                            | {
                                                                                                                                                            build?(obj: ExtensionBoundSchema, desc: Record<string, any>): any;
                                                                                                                                                            }
                                                                                                                                                            | undefined;

                                                                                                                                                              property messages

                                                                                                                                                              messages?: LanguageMessages | string | undefined;

                                                                                                                                                                property modifiers

                                                                                                                                                                modifiers?: Record<string, (rule: any, enabled?: boolean) => any> | undefined;

                                                                                                                                                                  property overrides

                                                                                                                                                                  overrides?: Record<string, (value: any) => Schema> | undefined;

                                                                                                                                                                    property properties

                                                                                                                                                                    properties?: Record<string, any> | undefined;

                                                                                                                                                                      property rules

                                                                                                                                                                      rules?: Record<string, ExtensionRule & ThisType<SchemaInternals>> | undefined;

                                                                                                                                                                        property terms

                                                                                                                                                                        terms?: Record<string, ExtensionTerm> | undefined;

                                                                                                                                                                          property type

                                                                                                                                                                          type: string;

                                                                                                                                                                            method args

                                                                                                                                                                            args: (...args: SchemaLike[]) => Schema;

                                                                                                                                                                              method prepare

                                                                                                                                                                              prepare: (value: any, helpers: CustomHelpers) => any;

                                                                                                                                                                                method rebuild

                                                                                                                                                                                rebuild: (schema: ExtensionBoundSchema) => void;

                                                                                                                                                                                  method validate

                                                                                                                                                                                  validate: (value: any, helpers: CustomHelpers) => any;

                                                                                                                                                                                    interface ExtensionFlag

                                                                                                                                                                                    interface ExtensionFlag {}

                                                                                                                                                                                      property default

                                                                                                                                                                                      default?: any;

                                                                                                                                                                                        property setter

                                                                                                                                                                                        setter?: string | undefined;

                                                                                                                                                                                          interface ExtensionRule

                                                                                                                                                                                          interface ExtensionRule {}

                                                                                                                                                                                            property alias

                                                                                                                                                                                            alias?: string | undefined;
                                                                                                                                                                                            • alternative name for this rule.

                                                                                                                                                                                            property args

                                                                                                                                                                                            args?: Array<RuleArgs | string> | undefined;
                                                                                                                                                                                            • list of arguments accepted by method.

                                                                                                                                                                                            property convert

                                                                                                                                                                                            convert?: boolean | undefined;
                                                                                                                                                                                            • Dual rule: converts or validates.

                                                                                                                                                                                            property manifest

                                                                                                                                                                                            manifest?: boolean | undefined;

                                                                                                                                                                                              property method

                                                                                                                                                                                              method?: RuleMethod | false | undefined;
                                                                                                                                                                                              • rule body.

                                                                                                                                                                                              property multi

                                                                                                                                                                                              multi?: boolean | undefined;
                                                                                                                                                                                              • whether rule supports multiple invocations.

                                                                                                                                                                                              property priority

                                                                                                                                                                                              priority?: boolean | undefined;
                                                                                                                                                                                              • undocumented flags.

                                                                                                                                                                                              method validate

                                                                                                                                                                                              validate: (
                                                                                                                                                                                              value: any,
                                                                                                                                                                                              helpers: any,
                                                                                                                                                                                              args: Record<string, any>,
                                                                                                                                                                                              options: any
                                                                                                                                                                                              ) => any;
                                                                                                                                                                                              • validation function.

                                                                                                                                                                                              interface ExtensionTerm

                                                                                                                                                                                              interface ExtensionTerm {}

                                                                                                                                                                                                property init

                                                                                                                                                                                                init: any[] | null;

                                                                                                                                                                                                  property manifest

                                                                                                                                                                                                  manifest?:
                                                                                                                                                                                                  | Record<string, 'schema' | 'single' | ExtensionTermManifest>
                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                    property register

                                                                                                                                                                                                    register?: any;

                                                                                                                                                                                                      interface ExtensionTermManifest

                                                                                                                                                                                                      interface ExtensionTermManifest {}

                                                                                                                                                                                                        property mapped

                                                                                                                                                                                                        mapped: {
                                                                                                                                                                                                        from: string;
                                                                                                                                                                                                        to: string;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          interface FunctionSchema

                                                                                                                                                                                                          interface FunctionSchema extends ObjectSchema {}

                                                                                                                                                                                                            method arity

                                                                                                                                                                                                            arity: (n: number) => this;
                                                                                                                                                                                                            • Specifies the arity of the function where:

                                                                                                                                                                                                              Parameter n

                                                                                                                                                                                                              the arity expected.

                                                                                                                                                                                                            method class

                                                                                                                                                                                                            class: () => this;
                                                                                                                                                                                                            • Requires the function to be a class.

                                                                                                                                                                                                            method maxArity

                                                                                                                                                                                                            maxArity: (n: number) => this;
                                                                                                                                                                                                            • Specifies the minimal arity of the function where:

                                                                                                                                                                                                              Parameter n

                                                                                                                                                                                                              the minimal arity expected.

                                                                                                                                                                                                            method minArity

                                                                                                                                                                                                            minArity: (n: number) => this;
                                                                                                                                                                                                            • Specifies the minimal arity of the function where:

                                                                                                                                                                                                              Parameter n

                                                                                                                                                                                                              the minimal arity expected.

                                                                                                                                                                                                            interface GetRuleOptions

                                                                                                                                                                                                            interface GetRuleOptions {}

                                                                                                                                                                                                              property args

                                                                                                                                                                                                              args?: Record<string, any> | undefined;

                                                                                                                                                                                                                property method

                                                                                                                                                                                                                method?: string | undefined;

                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                    property operator

                                                                                                                                                                                                                    operator?: string | undefined;

                                                                                                                                                                                                                      interface GuidOptions

                                                                                                                                                                                                                      interface GuidOptions {}

                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                        version: GuidVersions[] | GuidVersions;

                                                                                                                                                                                                                          interface HexOptions

                                                                                                                                                                                                                          interface HexOptions {}

                                                                                                                                                                                                                            property byteAligned

                                                                                                                                                                                                                            byteAligned?: boolean | undefined;
                                                                                                                                                                                                                            • hex decoded representation must be byte aligned. false

                                                                                                                                                                                                                            interface HierarchySeparatorOptions

                                                                                                                                                                                                                            interface HierarchySeparatorOptions {}

                                                                                                                                                                                                                              property separator

                                                                                                                                                                                                                              separator?: string | false | undefined;
                                                                                                                                                                                                                              • overrides the default . hierarchy separator. Set to false to treat the key as a literal value.

                                                                                                                                                                                                                                '.'

                                                                                                                                                                                                                              interface IpOptions

                                                                                                                                                                                                                              interface IpOptions {}

                                                                                                                                                                                                                                property cidr

                                                                                                                                                                                                                                cidr?: PresenceMode | undefined;
                                                                                                                                                                                                                                • Used to determine if a CIDR is allowed or not. Valid values: optional, required, forbidden

                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                version?: string | string[] | undefined;
                                                                                                                                                                                                                                • One or more IP address versions to validate against. Valid values: ipv4, ipv6, ipvfuture

                                                                                                                                                                                                                                interface IsSchemaOptions

                                                                                                                                                                                                                                interface IsSchemaOptions {}

                                                                                                                                                                                                                                  property legacy

                                                                                                                                                                                                                                  legacy: boolean;
                                                                                                                                                                                                                                  • If true, will identify schemas from older versions of joi, otherwise will throw an error.

                                                                                                                                                                                                                                    false

                                                                                                                                                                                                                                  interface LanguageMessageTemplate

                                                                                                                                                                                                                                  interface LanguageMessageTemplate {}

                                                                                                                                                                                                                                    property rendered

                                                                                                                                                                                                                                    rendered: string;

                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                      source: string;

                                                                                                                                                                                                                                        interface LinkSchema

                                                                                                                                                                                                                                        interface LinkSchema extends AnySchema {}

                                                                                                                                                                                                                                          method concat

                                                                                                                                                                                                                                          concat: (schema: Schema) => this;
                                                                                                                                                                                                                                          • Same as any.concat() but the schema is merged after the link is resolved which allows merging with schemas of the same type as the resolved link. Will throw an exception during validation if the merged types are not compatible.

                                                                                                                                                                                                                                          method ref

                                                                                                                                                                                                                                          ref: (ref: string) => this;
                                                                                                                                                                                                                                          • Initializes the schema after constructions for cases where the schema has to be constructed first and then initialized. If ref was not passed to the constructor, link.ref() must be called prior to usaged.

                                                                                                                                                                                                                                          interface ModifyOptions

                                                                                                                                                                                                                                          interface ModifyOptions {}

                                                                                                                                                                                                                                            property each

                                                                                                                                                                                                                                            each?: boolean | undefined;

                                                                                                                                                                                                                                              property once

                                                                                                                                                                                                                                              once?: boolean | undefined;

                                                                                                                                                                                                                                                property ref

                                                                                                                                                                                                                                                ref?: boolean | undefined;

                                                                                                                                                                                                                                                  property schema

                                                                                                                                                                                                                                                  schema?: boolean | undefined;

                                                                                                                                                                                                                                                    interface MutateRegisterOptions

                                                                                                                                                                                                                                                    interface MutateRegisterOptions {}

                                                                                                                                                                                                                                                      property family

                                                                                                                                                                                                                                                      family?: any;

                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                        key?: any;

                                                                                                                                                                                                                                                          interface NumberSchema

                                                                                                                                                                                                                                                          interface NumberSchema extends AnySchema {}

                                                                                                                                                                                                                                                            method greater

                                                                                                                                                                                                                                                            greater: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                            • Specifies that the value must be greater than limit. It can also be a reference to another field.

                                                                                                                                                                                                                                                            method integer

                                                                                                                                                                                                                                                            integer: () => this;
                                                                                                                                                                                                                                                            • Requires the number to be an integer (no floating point).

                                                                                                                                                                                                                                                            method less

                                                                                                                                                                                                                                                            less: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                            • Specifies that the value must be less than limit. It can also be a reference to another field.

                                                                                                                                                                                                                                                            method max

                                                                                                                                                                                                                                                            max: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                            • Specifies the maximum value. It can also be a reference to another field.

                                                                                                                                                                                                                                                            method min

                                                                                                                                                                                                                                                            min: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                            • Specifies the minimum value. It can also be a reference to another field.

                                                                                                                                                                                                                                                            method multiple

                                                                                                                                                                                                                                                            multiple: (base: number | Reference) => this;
                                                                                                                                                                                                                                                            • Specifies that the value must be a multiple of base.

                                                                                                                                                                                                                                                            method negative

                                                                                                                                                                                                                                                            negative: () => this;
                                                                                                                                                                                                                                                            • Requires the number to be negative.

                                                                                                                                                                                                                                                            method port

                                                                                                                                                                                                                                                            port: () => this;
                                                                                                                                                                                                                                                            • Requires the number to be a TCP port, so between 0 and 65535.

                                                                                                                                                                                                                                                            method positive

                                                                                                                                                                                                                                                            positive: () => this;
                                                                                                                                                                                                                                                            • Requires the number to be positive.

                                                                                                                                                                                                                                                            method precision

                                                                                                                                                                                                                                                            precision: (limit: number) => this;
                                                                                                                                                                                                                                                            • Specifies the maximum number of decimal places where:

                                                                                                                                                                                                                                                              Parameter limit

                                                                                                                                                                                                                                                              the maximum number of decimal places allowed.

                                                                                                                                                                                                                                                            method sign

                                                                                                                                                                                                                                                            sign: (sign: 'positive' | 'negative') => this;
                                                                                                                                                                                                                                                            • Requires the number to be negative or positive.

                                                                                                                                                                                                                                                            method unsafe

                                                                                                                                                                                                                                                            unsafe: (enabled?: any) => this;
                                                                                                                                                                                                                                                            • Allows the number to be outside of JavaScript's safety range (Number.MIN_SAFE_INTEGER & Number.MAX_SAFE_INTEGER).

                                                                                                                                                                                                                                                            interface ObjectPatternOptions

                                                                                                                                                                                                                                                            interface ObjectPatternOptions {}

                                                                                                                                                                                                                                                              property fallthrough

                                                                                                                                                                                                                                                              fallthrough?: boolean | undefined;

                                                                                                                                                                                                                                                                property matches

                                                                                                                                                                                                                                                                matches: SchemaLike | Reference;

                                                                                                                                                                                                                                                                  interface ObjectSchema

                                                                                                                                                                                                                                                                  interface ObjectSchema<TSchema = any> extends AnySchema {}

                                                                                                                                                                                                                                                                    method and

                                                                                                                                                                                                                                                                    and: (...peers: Array<string | HierarchySeparatorOptions>) => this;
                                                                                                                                                                                                                                                                    • Defines an all-or-nothing relationship between keys where if one of the peers is present, all of them are required as well.

                                                                                                                                                                                                                                                                      Optional settings must be the last argument.

                                                                                                                                                                                                                                                                    method append

                                                                                                                                                                                                                                                                    append: (schema?: SchemaMap<TSchema>) => this;
                                                                                                                                                                                                                                                                    • Appends the allowed object keys. If schema is null, undefined, or {}, no changes will be applied.

                                                                                                                                                                                                                                                                    method assert

                                                                                                                                                                                                                                                                    assert: (ref: string | Reference, schema: SchemaLike, message?: string) => this;
                                                                                                                                                                                                                                                                    • Verifies an assertion where.

                                                                                                                                                                                                                                                                    method instance

                                                                                                                                                                                                                                                                    instance: (constructor: Function, name?: string) => this;
                                                                                                                                                                                                                                                                    • Requires the object to be an instance of a given constructor.

                                                                                                                                                                                                                                                                      Parameter constructor

                                                                                                                                                                                                                                                                      the constructor function that the object must be an instance of.

                                                                                                                                                                                                                                                                      Parameter name

                                                                                                                                                                                                                                                                      an alternate name to use in validation errors. This is useful when the constructor function does not have a name.

                                                                                                                                                                                                                                                                    method keys

                                                                                                                                                                                                                                                                    keys: (schema?: SchemaMap<TSchema>) => this;
                                                                                                                                                                                                                                                                    • Sets or extends the allowed object keys.

                                                                                                                                                                                                                                                                    method length

                                                                                                                                                                                                                                                                    length: (limit: number) => this;
                                                                                                                                                                                                                                                                    • Specifies the exact number of keys in the object.

                                                                                                                                                                                                                                                                    method max

                                                                                                                                                                                                                                                                    max: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                                    • Specifies the maximum number of keys in the object.

                                                                                                                                                                                                                                                                    method min

                                                                                                                                                                                                                                                                    min: (limit: number | Reference) => this;
                                                                                                                                                                                                                                                                    • Specifies the minimum number of keys in the object.

                                                                                                                                                                                                                                                                    method nand

                                                                                                                                                                                                                                                                    nand: (...peers: Array<string | HierarchySeparatorOptions>) => this;
                                                                                                                                                                                                                                                                    • Defines a relationship between keys where not all peers can be present at the same time.

                                                                                                                                                                                                                                                                      Optional settings must be the last argument.

                                                                                                                                                                                                                                                                    method or

                                                                                                                                                                                                                                                                    or: (...peers: Array<string | HierarchySeparatorOptions>) => this;
                                                                                                                                                                                                                                                                    • Defines a relationship between keys where one of the peers is required (and more than one is allowed).

                                                                                                                                                                                                                                                                      Optional settings must be the last argument.

                                                                                                                                                                                                                                                                    method oxor

                                                                                                                                                                                                                                                                    oxor: (...peers: Array<string | HierarchySeparatorOptions>) => this;
                                                                                                                                                                                                                                                                    • Defines an exclusive relationship between a set of keys where only one is allowed but none are required.

                                                                                                                                                                                                                                                                      Optional settings must be the last argument.

                                                                                                                                                                                                                                                                    method pattern

                                                                                                                                                                                                                                                                    pattern: (
                                                                                                                                                                                                                                                                    pattern: RegExp | SchemaLike,
                                                                                                                                                                                                                                                                    schema: SchemaLike,
                                                                                                                                                                                                                                                                    options?: ObjectPatternOptions
                                                                                                                                                                                                                                                                    ) => this;
                                                                                                                                                                                                                                                                    • Specify validation rules for unknown keys matching a pattern.

                                                                                                                                                                                                                                                                      Parameter pattern

                                                                                                                                                                                                                                                                      a pattern that can be either a regular expression or a joi schema that will be tested against the unknown key names

                                                                                                                                                                                                                                                                      Parameter schema

                                                                                                                                                                                                                                                                      the schema object matching keys must validate against

                                                                                                                                                                                                                                                                    method ref

                                                                                                                                                                                                                                                                    ref: () => this;
                                                                                                                                                                                                                                                                    • Requires the object to be a Joi reference.

                                                                                                                                                                                                                                                                    method regex

                                                                                                                                                                                                                                                                    regex: () => this;
                                                                                                                                                                                                                                                                    • Requires the object to be a RegExp object.

                                                                                                                                                                                                                                                                    method rename

                                                                                                                                                                                                                                                                    rename: (from: string | RegExp, to: string, options?: RenameOptions) => this;
                                                                                                                                                                                                                                                                    • Renames a key to another name (deletes the renamed key).

                                                                                                                                                                                                                                                                    method schema

                                                                                                                                                                                                                                                                    schema: (type?: SchemaLike) => this;
                                                                                                                                                                                                                                                                    • Requires the object to be a Joi schema instance.

                                                                                                                                                                                                                                                                    method unknown

                                                                                                                                                                                                                                                                    unknown: (allow?: boolean) => this;
                                                                                                                                                                                                                                                                    • Overrides the handling of unknown keys for the scope of the current object only (does not apply to children).

                                                                                                                                                                                                                                                                    method with

                                                                                                                                                                                                                                                                    with: (
                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                    peers: string | string[],
                                                                                                                                                                                                                                                                    options?: HierarchySeparatorOptions
                                                                                                                                                                                                                                                                    ) => this;
                                                                                                                                                                                                                                                                    • Requires the presence of other keys whenever the specified key is present.

                                                                                                                                                                                                                                                                    method without

                                                                                                                                                                                                                                                                    without: (
                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                    peers: string | string[],
                                                                                                                                                                                                                                                                    options?: HierarchySeparatorOptions
                                                                                                                                                                                                                                                                    ) => this;
                                                                                                                                                                                                                                                                    • Forbids the presence of other keys whenever the specified is present.

                                                                                                                                                                                                                                                                    method xor

                                                                                                                                                                                                                                                                    xor: (...peers: Array<string | HierarchySeparatorOptions>) => this;
                                                                                                                                                                                                                                                                    • Defines an exclusive relationship between a set of keys. one of them is required but not at the same time.

                                                                                                                                                                                                                                                                      Optional settings must be the last argument.

                                                                                                                                                                                                                                                                    interface Reference

                                                                                                                                                                                                                                                                    interface Reference extends Exclude<ReferenceOptions, 'prefix'> {}

                                                                                                                                                                                                                                                                      property depth

                                                                                                                                                                                                                                                                      depth: number;

                                                                                                                                                                                                                                                                        property display

                                                                                                                                                                                                                                                                        display: string;

                                                                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                                                                          key: string;

                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                            path: string[];

                                                                                                                                                                                                                                                                              property root

                                                                                                                                                                                                                                                                              root: string;

                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                                                                                                    interface ReferenceOptions

                                                                                                                                                                                                                                                                                    interface ReferenceOptions extends HierarchySeparatorOptions {}

                                                                                                                                                                                                                                                                                      property adjust

                                                                                                                                                                                                                                                                                      adjust?: ((value: any) => any) | undefined;
                                                                                                                                                                                                                                                                                      • a function with the signature function(value) where value is the resolved reference value and the return value is the adjusted value to use. Note that the adjust feature will not perform any type validation on the adjusted value and it must match the value expected by the rule it is used in. Cannot be used with map.

                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                        (value) => value + 5

                                                                                                                                                                                                                                                                                      property ancestor

                                                                                                                                                                                                                                                                                      ancestor?: number | undefined;
                                                                                                                                                                                                                                                                                      • If set to a number, sets the reference relative starting point. Cannot be combined with separator prefix characters. Defaults to the reference key prefix (or 1 if none present)

                                                                                                                                                                                                                                                                                      property in

                                                                                                                                                                                                                                                                                      in?: boolean | undefined;
                                                                                                                                                                                                                                                                                      • creates an in-reference.

                                                                                                                                                                                                                                                                                      property iterables

                                                                                                                                                                                                                                                                                      iterables?: boolean | undefined;
                                                                                                                                                                                                                                                                                      • when true, the reference resolves by reaching into maps and sets.

                                                                                                                                                                                                                                                                                      property map

                                                                                                                                                                                                                                                                                      map?: Array<[any, any]> | undefined;
                                                                                                                                                                                                                                                                                      • an array of array pairs using the format [[key, value], [key, value]] used to maps the resolved reference value to another value. If the resolved value is not in the map, it is returned as-is. Cannot be used with adjust.

                                                                                                                                                                                                                                                                                      property prefix

                                                                                                                                                                                                                                                                                      prefix?:
                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                      * references to the globally provided context preference.
                                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                                      * @default '$'
                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                      global?: string | undefined;
                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                      * references to error-specific or rule specific context.
                                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                                      * @default '#'
                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                      local?: string | undefined;
                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                      * references to the root value being validated.
                                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                                      * @default '/'
                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                      root?: string | undefined;
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                      • overrides default prefix characters.

                                                                                                                                                                                                                                                                                      interface RenameOptions

                                                                                                                                                                                                                                                                                      interface RenameOptions {}

                                                                                                                                                                                                                                                                                        property alias

                                                                                                                                                                                                                                                                                        alias?: boolean | undefined;
                                                                                                                                                                                                                                                                                        • if true, does not delete the old key name, keeping both the new and old keys in place.

                                                                                                                                                                                                                                                                                          false

                                                                                                                                                                                                                                                                                        property ignoreUndefined

                                                                                                                                                                                                                                                                                        ignoreUndefined?: boolean | undefined;
                                                                                                                                                                                                                                                                                        • if true, skip renaming of a key if it's undefined.

                                                                                                                                                                                                                                                                                          false

                                                                                                                                                                                                                                                                                        property multiple

                                                                                                                                                                                                                                                                                        multiple?: boolean | undefined;
                                                                                                                                                                                                                                                                                        • if true, allows renaming multiple keys to the same destination where the last rename wins.

                                                                                                                                                                                                                                                                                          false

                                                                                                                                                                                                                                                                                        property override

                                                                                                                                                                                                                                                                                        override?: boolean | undefined;
                                                                                                                                                                                                                                                                                        • if true, allows renaming a key over an existing key.

                                                                                                                                                                                                                                                                                          false

                                                                                                                                                                                                                                                                                        interface Root

                                                                                                                                                                                                                                                                                        interface Root {}

                                                                                                                                                                                                                                                                                          property cache

                                                                                                                                                                                                                                                                                          cache: CacheConfiguration;

                                                                                                                                                                                                                                                                                            property override

                                                                                                                                                                                                                                                                                            override: symbol;
                                                                                                                                                                                                                                                                                            • A special value used with any.allow(), any.invalid(), and any.valid() as the first value to reset any previously set values.

                                                                                                                                                                                                                                                                                            property ValidationError

                                                                                                                                                                                                                                                                                            ValidationError: new (
                                                                                                                                                                                                                                                                                            message: string,
                                                                                                                                                                                                                                                                                            details: any,
                                                                                                                                                                                                                                                                                            original: any
                                                                                                                                                                                                                                                                                            ) => ValidationError;

                                                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                                                              version: string;
                                                                                                                                                                                                                                                                                              • Current version of the joi package.

                                                                                                                                                                                                                                                                                              method allow

                                                                                                                                                                                                                                                                                              allow: (...values: any[]) => Schema;
                                                                                                                                                                                                                                                                                              • Whitelists a value

                                                                                                                                                                                                                                                                                              method alt

                                                                                                                                                                                                                                                                                              alt: {
                                                                                                                                                                                                                                                                                              (types: SchemaLike[]): AlternativesSchema;
                                                                                                                                                                                                                                                                                              (...types: SchemaLike[]): AlternativesSchema;
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • Alias for alternatives

                                                                                                                                                                                                                                                                                              method alternatives

                                                                                                                                                                                                                                                                                              alternatives: {
                                                                                                                                                                                                                                                                                              (types: SchemaLike[]): AlternativesSchema;
                                                                                                                                                                                                                                                                                              (...types: SchemaLike[]): AlternativesSchema;
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • Generates a type that will match one of the provided alternative schemas

                                                                                                                                                                                                                                                                                              method any

                                                                                                                                                                                                                                                                                              any: () => AnySchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches any data type.

                                                                                                                                                                                                                                                                                              method array

                                                                                                                                                                                                                                                                                              array: () => ArraySchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches an array data type.

                                                                                                                                                                                                                                                                                              method assert

                                                                                                                                                                                                                                                                                              assert: {
                                                                                                                                                                                                                                                                                              (value: any, schema: SchemaLike, options?: ValidationOptions): void;
                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                              value: any,
                                                                                                                                                                                                                                                                                              schema: SchemaLike,
                                                                                                                                                                                                                                                                                              message: string | Error,
                                                                                                                                                                                                                                                                                              options?: ValidationOptions
                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • Validates a value against a schema and throws if validation fails.

                                                                                                                                                                                                                                                                                                Parameter value

                                                                                                                                                                                                                                                                                                the value to validate.

                                                                                                                                                                                                                                                                                                Parameter schema

                                                                                                                                                                                                                                                                                                the schema object.

                                                                                                                                                                                                                                                                                                Parameter message

                                                                                                                                                                                                                                                                                                optional message string prefix added in front of the error message. may also be an Error object.

                                                                                                                                                                                                                                                                                              method attempt

                                                                                                                                                                                                                                                                                              attempt: {
                                                                                                                                                                                                                                                                                              (value: any, schema: SchemaLike, options?: ValidationOptions): any;
                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                              value: any,
                                                                                                                                                                                                                                                                                              schema: SchemaLike,
                                                                                                                                                                                                                                                                                              message: string | Error,
                                                                                                                                                                                                                                                                                              options?: ValidationOptions
                                                                                                                                                                                                                                                                                              ): any;
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • Validates a value against a schema, returns valid object, and throws if validation fails.

                                                                                                                                                                                                                                                                                                Parameter value

                                                                                                                                                                                                                                                                                                the value to validate.

                                                                                                                                                                                                                                                                                                Parameter schema

                                                                                                                                                                                                                                                                                                the schema object.

                                                                                                                                                                                                                                                                                                Parameter message

                                                                                                                                                                                                                                                                                                optional message string prefix added in front of the error message. may also be an Error object.

                                                                                                                                                                                                                                                                                              method binary

                                                                                                                                                                                                                                                                                              binary: () => BinarySchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches a Buffer data type (as well as the strings which will be converted to Buffers).

                                                                                                                                                                                                                                                                                              method bool

                                                                                                                                                                                                                                                                                              bool: () => BooleanSchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via bool().

                                                                                                                                                                                                                                                                                              method boolean

                                                                                                                                                                                                                                                                                              boolean: () => BooleanSchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via bool().

                                                                                                                                                                                                                                                                                              method build

                                                                                                                                                                                                                                                                                              build: (...args: any[]) => any;
                                                                                                                                                                                                                                                                                              • Unsure, maybe alias for compile?

                                                                                                                                                                                                                                                                                              method checkPreferences

                                                                                                                                                                                                                                                                                              checkPreferences: (prefs: ValidationOptions) => void;
                                                                                                                                                                                                                                                                                              • Checks if the provided preferences are valid.

                                                                                                                                                                                                                                                                                                Throws an exception if the prefs object is invalid.

                                                                                                                                                                                                                                                                                                The method is provided to perform inputs validation for the any.validate() and any.validateAsync() methods. Validation is not performed automatically for performance reasons. Instead, manually validate the preferences passed once and reuse.

                                                                                                                                                                                                                                                                                              method compile

                                                                                                                                                                                                                                                                                              compile: (schema: SchemaLike, options?: CompileOptions) => Schema;
                                                                                                                                                                                                                                                                                              • Converts literal schema definition to joi schema object (or returns the same back if already a joi schema object).

                                                                                                                                                                                                                                                                                              method custom

                                                                                                                                                                                                                                                                                              custom: (fn: CustomValidator, description?: string) => Schema;
                                                                                                                                                                                                                                                                                              • Creates a custom validation schema.

                                                                                                                                                                                                                                                                                              method date

                                                                                                                                                                                                                                                                                              date: () => DateSchema;
                                                                                                                                                                                                                                                                                              • Generates a schema object that matches a date type (as well as a JavaScript date string or number of milliseconds).

                                                                                                                                                                                                                                                                                              method defaults

                                                                                                                                                                                                                                                                                              defaults: (fn: SchemaFunction) => Root;
                                                                                                                                                                                                                                                                                              • Creates a new Joi instance that will apply defaults onto newly created schemas through the use of the fn function that takes exactly one argument, the schema being created.

                                                                                                                                                                                                                                                                                                Parameter fn

                                                                                                                                                                                                                                                                                                The function must always return a schema, even if untransformed.

                                                                                                                                                                                                                                                                                              method disallow

                                                                                                                                                                                                                                                                                              disallow: (...values: any[]) => Schema;

                                                                                                                                                                                                                                                                                                method equal

                                                                                                                                                                                                                                                                                                equal: (...values: any[]) => Schema;

                                                                                                                                                                                                                                                                                                  method exist

                                                                                                                                                                                                                                                                                                  exist: () => Schema;
                                                                                                                                                                                                                                                                                                  • Alias of required.

                                                                                                                                                                                                                                                                                                  method expression

                                                                                                                                                                                                                                                                                                  expression: (template: string, options?: ReferenceOptions) => any;
                                                                                                                                                                                                                                                                                                  • Generates a dynamic expression using a template string.

                                                                                                                                                                                                                                                                                                  method extend

                                                                                                                                                                                                                                                                                                  extend: (...extensions: Array<Extension | ExtensionFactory>) => any;
                                                                                                                                                                                                                                                                                                  • Creates a new Joi instance customized with the extension(s) you provide included.

                                                                                                                                                                                                                                                                                                  method forbidden

                                                                                                                                                                                                                                                                                                  forbidden: () => Schema;
                                                                                                                                                                                                                                                                                                  • Marks a key as forbidden which will not allow any value except undefined. Used to explicitly forbid keys.

                                                                                                                                                                                                                                                                                                  method func

                                                                                                                                                                                                                                                                                                  func: () => FunctionSchema;
                                                                                                                                                                                                                                                                                                  • Generates a schema object that matches a function type.

                                                                                                                                                                                                                                                                                                  method function

                                                                                                                                                                                                                                                                                                  function: () => FunctionSchema;
                                                                                                                                                                                                                                                                                                  • Generates a schema object that matches a function type.

                                                                                                                                                                                                                                                                                                  method in

                                                                                                                                                                                                                                                                                                  in: (ref: string, options?: ReferenceOptions) => Reference;
                                                                                                                                                                                                                                                                                                  • Creates a reference that when resolved, is used as an array of values to match against the rule.

                                                                                                                                                                                                                                                                                                  method invalid

                                                                                                                                                                                                                                                                                                  invalid: (...values: any[]) => Schema;
                                                                                                                                                                                                                                                                                                  • Blacklists a value

                                                                                                                                                                                                                                                                                                  method isError

                                                                                                                                                                                                                                                                                                  isError: (error: any) => error is ValidationError;
                                                                                                                                                                                                                                                                                                  • Checks whether or not the provided argument is an instance of ValidationError

                                                                                                                                                                                                                                                                                                  method isExpression

                                                                                                                                                                                                                                                                                                  isExpression: (expression: any) => boolean;
                                                                                                                                                                                                                                                                                                  • Checks whether or not the provided argument is an expression.

                                                                                                                                                                                                                                                                                                  method isRef

                                                                                                                                                                                                                                                                                                  isRef: (ref: any) => ref is Reference;
                                                                                                                                                                                                                                                                                                  • Checks whether or not the provided argument is a reference. It's especially useful if you want to post-process error messages.

                                                                                                                                                                                                                                                                                                  method isSchema

                                                                                                                                                                                                                                                                                                  isSchema: (schema: any, options?: CompileOptions) => boolean;
                                                                                                                                                                                                                                                                                                  • Checks whether or not the provided argument is a joi schema.

                                                                                                                                                                                                                                                                                                  link: (ref?: string) => LinkSchema;
                                                                                                                                                                                                                                                                                                  • Links to another schema node and reuses it for validation, typically for creative recursive schemas.

                                                                                                                                                                                                                                                                                                    Parameter ref

                                                                                                                                                                                                                                                                                                    the reference to the linked schema node. Cannot reference itself or its children as well as other links. Links can be expressed in relative terms like value references (Joi.link('...')), in absolute terms from the schema run-time root (Joi.link('/a')), or using schema ids implicitly using object keys or explicitly using any.id() (Joi.link('#a.b.c')).

                                                                                                                                                                                                                                                                                                  method not

                                                                                                                                                                                                                                                                                                  not: (...values: any[]) => Schema;

                                                                                                                                                                                                                                                                                                    method number

                                                                                                                                                                                                                                                                                                    number: () => NumberSchema;
                                                                                                                                                                                                                                                                                                    • Generates a schema object that matches a number data type (as well as strings that can be converted to numbers).

                                                                                                                                                                                                                                                                                                    method object

                                                                                                                                                                                                                                                                                                    object: <TSchema = any, T = TSchema>(
                                                                                                                                                                                                                                                                                                    schema?: SchemaMap<T>
                                                                                                                                                                                                                                                                                                    ) => ObjectSchema<TSchema>;
                                                                                                                                                                                                                                                                                                    • Generates a schema object that matches an object data type (as well as JSON strings that have been parsed into objects).

                                                                                                                                                                                                                                                                                                    method optional

                                                                                                                                                                                                                                                                                                    optional: () => Schema;
                                                                                                                                                                                                                                                                                                    • Marks a key as optional which will allow undefined as values. Used to annotate the schema for readability as all keys are optional by default.

                                                                                                                                                                                                                                                                                                    method options

                                                                                                                                                                                                                                                                                                    options: (...args: any[]) => any;
                                                                                                                                                                                                                                                                                                    • Unsure, maybe alias for preferences?

                                                                                                                                                                                                                                                                                                    method preferences

                                                                                                                                                                                                                                                                                                    preferences: (options: ValidationOptions) => Schema;
                                                                                                                                                                                                                                                                                                    • Overrides the global validate() options for the current key and any sub-key.

                                                                                                                                                                                                                                                                                                    method prefs

                                                                                                                                                                                                                                                                                                    prefs: (options: ValidationOptions) => Schema;
                                                                                                                                                                                                                                                                                                    • Overrides the global validate() options for the current key and any sub-key.

                                                                                                                                                                                                                                                                                                    method ref

                                                                                                                                                                                                                                                                                                    ref: (key: string, options?: ReferenceOptions) => Reference;
                                                                                                                                                                                                                                                                                                    • Generates a reference to the value of the named key.

                                                                                                                                                                                                                                                                                                    method required

                                                                                                                                                                                                                                                                                                    required: () => Schema;
                                                                                                                                                                                                                                                                                                    • Marks a key as required which will not allow undefined as value. All keys are optional by default.

                                                                                                                                                                                                                                                                                                    method string

                                                                                                                                                                                                                                                                                                    string: () => StringSchema;
                                                                                                                                                                                                                                                                                                    • Generates a schema object that matches a string data type. Note that empty strings are not allowed by default and must be enabled with allow('').

                                                                                                                                                                                                                                                                                                    method symbol

                                                                                                                                                                                                                                                                                                    symbol: () => SymbolSchema;
                                                                                                                                                                                                                                                                                                    • Generates a schema object that matches any symbol.

                                                                                                                                                                                                                                                                                                    method trace

                                                                                                                                                                                                                                                                                                    trace: (...args: any[]) => any;
                                                                                                                                                                                                                                                                                                    • Unsure, maybe leaked from @hapi/lab/coverage/initialize

                                                                                                                                                                                                                                                                                                    method types

                                                                                                                                                                                                                                                                                                    types: () => {
                                                                                                                                                                                                                                                                                                    alternatives: AlternativesSchema;
                                                                                                                                                                                                                                                                                                    any: AnySchema;
                                                                                                                                                                                                                                                                                                    array: ArraySchema;
                                                                                                                                                                                                                                                                                                    binary: BinarySchema;
                                                                                                                                                                                                                                                                                                    boolean: BooleanSchema;
                                                                                                                                                                                                                                                                                                    date: DateSchema;
                                                                                                                                                                                                                                                                                                    function: FunctionSchema;
                                                                                                                                                                                                                                                                                                    link: LinkSchema;
                                                                                                                                                                                                                                                                                                    number: NumberSchema;
                                                                                                                                                                                                                                                                                                    object: ObjectSchema;
                                                                                                                                                                                                                                                                                                    string: StringSchema;
                                                                                                                                                                                                                                                                                                    symbol: SymbolSchema;
                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                    • Returns an object where each key is a plain joi schema type. Useful for creating type shortcuts using deconstruction. Note that the types are already formed and do not need to be called as functions (e.g. string, not string()).

                                                                                                                                                                                                                                                                                                    method untrace

                                                                                                                                                                                                                                                                                                    untrace: (...args: any[]) => any;

                                                                                                                                                                                                                                                                                                      method valid

                                                                                                                                                                                                                                                                                                      valid: (...values: any[]) => Schema;
                                                                                                                                                                                                                                                                                                      • Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.

                                                                                                                                                                                                                                                                                                      method when

                                                                                                                                                                                                                                                                                                      when: {
                                                                                                                                                                                                                                                                                                      (ref: string | Reference, options: WhenOptions): AlternativesSchema;
                                                                                                                                                                                                                                                                                                      (ref: Schema, options: WhenSchemaOptions): AlternativesSchema;
                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                      • Converts the type into an alternatives type where the conditions are merged into the type definition where:

                                                                                                                                                                                                                                                                                                      method x

                                                                                                                                                                                                                                                                                                      x: (template: string, options?: ReferenceOptions) => any;
                                                                                                                                                                                                                                                                                                      • Generates a dynamic expression using a template string.

                                                                                                                                                                                                                                                                                                      interface RuleArgs

                                                                                                                                                                                                                                                                                                      interface RuleArgs {}

                                                                                                                                                                                                                                                                                                        property assert

                                                                                                                                                                                                                                                                                                        assert?: ((value: any) => boolean) | AnySchema | undefined;

                                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                                          message?: string | undefined;

                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                              property ref

                                                                                                                                                                                                                                                                                                              ref?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                method normalize

                                                                                                                                                                                                                                                                                                                normalize: (value: any) => any;
                                                                                                                                                                                                                                                                                                                • Undocumented properties

                                                                                                                                                                                                                                                                                                                interface RuleOptions

                                                                                                                                                                                                                                                                                                                interface RuleOptions {}

                                                                                                                                                                                                                                                                                                                  property keep

                                                                                                                                                                                                                                                                                                                  keep?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                  • if true, the rules will not be replaced by the same unique rule later.

                                                                                                                                                                                                                                                                                                                    For example, Joi.number().min(1).rule({ keep: true }).min(2) will keep both min() rules instead of the later rule overriding the first.

                                                                                                                                                                                                                                                                                                                    false

                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                  message?: string | LanguageMessages | undefined;
                                                                                                                                                                                                                                                                                                                  • a single message string or a messages object where each key is an error code and corresponding message string as value.

                                                                                                                                                                                                                                                                                                                    The object is the same as the messages used as an option in any.validate(). The strings can be plain messages or a message template.

                                                                                                                                                                                                                                                                                                                  property warn

                                                                                                                                                                                                                                                                                                                  warn?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                  • if true, turns any error generated by the ruleset to warnings.

                                                                                                                                                                                                                                                                                                                  interface SchemaInternals

                                                                                                                                                                                                                                                                                                                  interface SchemaInternals {}

                                                                                                                                                                                                                                                                                                                    property $_super

                                                                                                                                                                                                                                                                                                                    $_super: Schema;
                                                                                                                                                                                                                                                                                                                    • Parent schema object.

                                                                                                                                                                                                                                                                                                                    property $_terms

                                                                                                                                                                                                                                                                                                                    $_terms: Record<string, any>;
                                                                                                                                                                                                                                                                                                                    • Terms of current schema.

                                                                                                                                                                                                                                                                                                                    method $_addRule

                                                                                                                                                                                                                                                                                                                    $_addRule: (rule: string | AddRuleOptions) => Schema;
                                                                                                                                                                                                                                                                                                                    • Adds a rule to current validation schema.

                                                                                                                                                                                                                                                                                                                    method $_compile

                                                                                                                                                                                                                                                                                                                    $_compile: (schema: SchemaLike, options?: CompileOptions) => Schema;
                                                                                                                                                                                                                                                                                                                    • Internally compiles schema.

                                                                                                                                                                                                                                                                                                                    method $_createError

                                                                                                                                                                                                                                                                                                                    $_createError: (
                                                                                                                                                                                                                                                                                                                    code: string,
                                                                                                                                                                                                                                                                                                                    value: any,
                                                                                                                                                                                                                                                                                                                    context: Context,
                                                                                                                                                                                                                                                                                                                    state: State,
                                                                                                                                                                                                                                                                                                                    prefs: ValidationOptions,
                                                                                                                                                                                                                                                                                                                    options?: CreateErrorOptions
                                                                                                                                                                                                                                                                                                                    ) => Err;
                                                                                                                                                                                                                                                                                                                    • Creates a joi error object.

                                                                                                                                                                                                                                                                                                                    method $_getFlag

                                                                                                                                                                                                                                                                                                                    $_getFlag: (name: string) => any;
                                                                                                                                                                                                                                                                                                                    • Get value from given flag.

                                                                                                                                                                                                                                                                                                                    method $_getRule

                                                                                                                                                                                                                                                                                                                    $_getRule: (name: string) => GetRuleOptions | undefined;
                                                                                                                                                                                                                                                                                                                    • Retrieve some rule configuration.

                                                                                                                                                                                                                                                                                                                    method $_mapLabels

                                                                                                                                                                                                                                                                                                                    $_mapLabels: (path: string | string[]) => string;

                                                                                                                                                                                                                                                                                                                      method $_match

                                                                                                                                                                                                                                                                                                                      $_match: (value: any, state: State, prefs: ValidationOptions) => boolean;
                                                                                                                                                                                                                                                                                                                      • Returns true if validations runs fine on given value.

                                                                                                                                                                                                                                                                                                                      method $_modify

                                                                                                                                                                                                                                                                                                                      $_modify: (options?: ModifyOptions) => Schema;

                                                                                                                                                                                                                                                                                                                        method $_mutateRebuild

                                                                                                                                                                                                                                                                                                                        $_mutateRebuild: () => this;
                                                                                                                                                                                                                                                                                                                        • Resets current schema.

                                                                                                                                                                                                                                                                                                                        method $_mutateRegister

                                                                                                                                                                                                                                                                                                                        $_mutateRegister: (schema: Schema, options?: MutateRegisterOptions) => void;

                                                                                                                                                                                                                                                                                                                          method $_property

                                                                                                                                                                                                                                                                                                                          $_property: (name: string) => any;
                                                                                                                                                                                                                                                                                                                          • Get value from given property.

                                                                                                                                                                                                                                                                                                                          method $_reach

                                                                                                                                                                                                                                                                                                                          $_reach: (path: string[]) => Schema;
                                                                                                                                                                                                                                                                                                                          • Get schema at given path.

                                                                                                                                                                                                                                                                                                                          method $_rootReferences

                                                                                                                                                                                                                                                                                                                          $_rootReferences: () => any;
                                                                                                                                                                                                                                                                                                                          • Get current schema root references.

                                                                                                                                                                                                                                                                                                                          method $_setFlag

                                                                                                                                                                                                                                                                                                                          $_setFlag: (flag: string, value: any, options?: SetFlagOptions) => void;
                                                                                                                                                                                                                                                                                                                          • Set flag to given value.

                                                                                                                                                                                                                                                                                                                          method $_validate

                                                                                                                                                                                                                                                                                                                          $_validate: (
                                                                                                                                                                                                                                                                                                                          value: any,
                                                                                                                                                                                                                                                                                                                          state: State,
                                                                                                                                                                                                                                                                                                                          prefs: ValidationOptions
                                                                                                                                                                                                                                                                                                                          ) => ValidationResult;
                                                                                                                                                                                                                                                                                                                          • Runs internal validations against given value.

                                                                                                                                                                                                                                                                                                                          interface SetFlagOptions

                                                                                                                                                                                                                                                                                                                          interface SetFlagOptions {}

                                                                                                                                                                                                                                                                                                                            property clone

                                                                                                                                                                                                                                                                                                                            clone: boolean;

                                                                                                                                                                                                                                                                                                                              interface State

                                                                                                                                                                                                                                                                                                                              interface State {}

                                                                                                                                                                                                                                                                                                                                property ancestors

                                                                                                                                                                                                                                                                                                                                ancestors?: any;

                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                  key?: string | undefined;

                                                                                                                                                                                                                                                                                                                                    property parent

                                                                                                                                                                                                                                                                                                                                    parent?: any;

                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                      path?: string | undefined;

                                                                                                                                                                                                                                                                                                                                        property reference

                                                                                                                                                                                                                                                                                                                                        reference?: any;

                                                                                                                                                                                                                                                                                                                                          method localize

                                                                                                                                                                                                                                                                                                                                          localize: (...args: any[]) => State;

                                                                                                                                                                                                                                                                                                                                            interface StringRegexOptions

                                                                                                                                                                                                                                                                                                                                            interface StringRegexOptions {}

                                                                                                                                                                                                                                                                                                                                              property invert

                                                                                                                                                                                                                                                                                                                                              invert?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                              • when true, the provided pattern will be disallowed instead of required.

                                                                                                                                                                                                                                                                                                                                                false

                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                              name?: string | undefined;
                                                                                                                                                                                                                                                                                                                                              • optional pattern name.

                                                                                                                                                                                                                                                                                                                                              interface StringSchema

                                                                                                                                                                                                                                                                                                                                              interface StringSchema extends AnySchema {}

                                                                                                                                                                                                                                                                                                                                                method alphanum

                                                                                                                                                                                                                                                                                                                                                alphanum: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to only contain a-z, A-Z, and 0-9.

                                                                                                                                                                                                                                                                                                                                                method base64

                                                                                                                                                                                                                                                                                                                                                base64: (options?: Base64Options) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid base64 string; does not check the decoded value.

                                                                                                                                                                                                                                                                                                                                                method case

                                                                                                                                                                                                                                                                                                                                                case: (direction: 'upper' | 'lower') => this;
                                                                                                                                                                                                                                                                                                                                                • Sets the required string case.

                                                                                                                                                                                                                                                                                                                                                method creditCard

                                                                                                                                                                                                                                                                                                                                                creditCard: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the number to be a credit card number (Using Lunh Algorithm).

                                                                                                                                                                                                                                                                                                                                                method dataUri

                                                                                                                                                                                                                                                                                                                                                dataUri: (options?: DataUriOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid data URI string.

                                                                                                                                                                                                                                                                                                                                                method domain

                                                                                                                                                                                                                                                                                                                                                domain: (options?: DomainOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid domain.

                                                                                                                                                                                                                                                                                                                                                method email

                                                                                                                                                                                                                                                                                                                                                email: (options?: EmailOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid email address.

                                                                                                                                                                                                                                                                                                                                                method guid

                                                                                                                                                                                                                                                                                                                                                guid: (options?: GuidOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid GUID.

                                                                                                                                                                                                                                                                                                                                                method hex

                                                                                                                                                                                                                                                                                                                                                hex: (options?: HexOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid hexadecimal string.

                                                                                                                                                                                                                                                                                                                                                method hostname

                                                                                                                                                                                                                                                                                                                                                hostname: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid hostname as per RFC1123.

                                                                                                                                                                                                                                                                                                                                                method insensitive

                                                                                                                                                                                                                                                                                                                                                insensitive: () => this;
                                                                                                                                                                                                                                                                                                                                                • Allows the value to match any whitelist of blacklist item in a case insensitive comparison.

                                                                                                                                                                                                                                                                                                                                                method ip

                                                                                                                                                                                                                                                                                                                                                ip: (options?: IpOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid ip address.

                                                                                                                                                                                                                                                                                                                                                method isoDate

                                                                                                                                                                                                                                                                                                                                                isoDate: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be in valid ISO 8601 date format.

                                                                                                                                                                                                                                                                                                                                                method isoDuration

                                                                                                                                                                                                                                                                                                                                                isoDuration: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be in valid ISO 8601 duration format.

                                                                                                                                                                                                                                                                                                                                                method length

                                                                                                                                                                                                                                                                                                                                                length: (limit: number | Reference, encoding?: string) => this;
                                                                                                                                                                                                                                                                                                                                                • Specifies the exact string length required

                                                                                                                                                                                                                                                                                                                                                  Parameter limit

                                                                                                                                                                                                                                                                                                                                                  the required string length. It can also be a reference to another field.

                                                                                                                                                                                                                                                                                                                                                  Parameter encoding

                                                                                                                                                                                                                                                                                                                                                  if specified, the string length is calculated in bytes using the provided encoding.

                                                                                                                                                                                                                                                                                                                                                method lowercase

                                                                                                                                                                                                                                                                                                                                                lowercase: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be all lowercase. If the validation convert option is on (enabled by default), the string will be forced to lowercase.

                                                                                                                                                                                                                                                                                                                                                method max

                                                                                                                                                                                                                                                                                                                                                max: (limit: number | Reference, encoding?: string) => this;
                                                                                                                                                                                                                                                                                                                                                • Specifies the maximum number of string characters.

                                                                                                                                                                                                                                                                                                                                                  Parameter limit

                                                                                                                                                                                                                                                                                                                                                  the maximum number of string characters allowed. It can also be a reference to another field.

                                                                                                                                                                                                                                                                                                                                                  Parameter encoding

                                                                                                                                                                                                                                                                                                                                                  if specified, the string length is calculated in bytes using the provided encoding.

                                                                                                                                                                                                                                                                                                                                                method min

                                                                                                                                                                                                                                                                                                                                                min: (limit: number | Reference, encoding?: string) => this;
                                                                                                                                                                                                                                                                                                                                                • Specifies the minimum number string characters.

                                                                                                                                                                                                                                                                                                                                                  Parameter limit

                                                                                                                                                                                                                                                                                                                                                  the minimum number of string characters required. It can also be a reference to another field.

                                                                                                                                                                                                                                                                                                                                                  Parameter encoding

                                                                                                                                                                                                                                                                                                                                                  if specified, the string length is calculated in bytes using the provided encoding.

                                                                                                                                                                                                                                                                                                                                                method normalize

                                                                                                                                                                                                                                                                                                                                                normalize: (form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD') => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be in a unicode normalized form. If the validation convert option is on (enabled by default), the string will be normalized.

                                                                                                                                                                                                                                                                                                                                                  Parameter form

                                                                                                                                                                                                                                                                                                                                                  The unicode normalization form to use. Valid values: NFC [default], NFD, NFKC, NFKD

                                                                                                                                                                                                                                                                                                                                                method pattern

                                                                                                                                                                                                                                                                                                                                                pattern: (pattern: RegExp, options?: string | StringRegexOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Defines a regular expression rule.

                                                                                                                                                                                                                                                                                                                                                  Parameter pattern

                                                                                                                                                                                                                                                                                                                                                  a regular expression object the string value must match against.

                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                  optional, can be: Name for patterns (useful with multiple patterns). Defaults to 'required'. An optional configuration object with the following supported properties: name - optional pattern name. invert - optional boolean flag. Defaults to false behavior. If specified as true, the provided pattern will be disallowed instead of required.

                                                                                                                                                                                                                                                                                                                                                method regex

                                                                                                                                                                                                                                                                                                                                                regex: (pattern: RegExp, options?: string | StringRegexOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Defines a regular expression rule.

                                                                                                                                                                                                                                                                                                                                                  Parameter pattern

                                                                                                                                                                                                                                                                                                                                                  a regular expression object the string value must match against.

                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                  optional, can be: Name for patterns (useful with multiple patterns). Defaults to 'required'. An optional configuration object with the following supported properties: name - optional pattern name. invert - optional boolean flag. Defaults to false behavior. If specified as true, the provided pattern will be disallowed instead of required.

                                                                                                                                                                                                                                                                                                                                                method replace

                                                                                                                                                                                                                                                                                                                                                replace: (pattern: RegExp | string, replacement: string) => this;
                                                                                                                                                                                                                                                                                                                                                • Replace characters matching the given pattern with the specified replacement string where:

                                                                                                                                                                                                                                                                                                                                                  Parameter pattern

                                                                                                                                                                                                                                                                                                                                                  a regular expression object to match against, or a string of which all occurrences will be replaced.

                                                                                                                                                                                                                                                                                                                                                  Parameter replacement

                                                                                                                                                                                                                                                                                                                                                  the string that will replace the pattern.

                                                                                                                                                                                                                                                                                                                                                method token

                                                                                                                                                                                                                                                                                                                                                token: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to only contain a-z, A-Z, 0-9, and underscore _.

                                                                                                                                                                                                                                                                                                                                                method trim

                                                                                                                                                                                                                                                                                                                                                trim: (enabled?: any) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to contain no whitespace before or after. If the validation convert option is on (enabled by default), the string will be trimmed.

                                                                                                                                                                                                                                                                                                                                                  Parameter enabled

                                                                                                                                                                                                                                                                                                                                                  optional parameter defaulting to true which allows you to reset the behavior of trim by providing a falsy value.

                                                                                                                                                                                                                                                                                                                                                method truncate

                                                                                                                                                                                                                                                                                                                                                truncate: (enabled?: boolean) => this;
                                                                                                                                                                                                                                                                                                                                                • Specifies whether the string.max() limit should be used as a truncation.

                                                                                                                                                                                                                                                                                                                                                  Parameter enabled

                                                                                                                                                                                                                                                                                                                                                  optional parameter defaulting to true which allows you to reset the behavior of truncate by providing a falsy value.

                                                                                                                                                                                                                                                                                                                                                method uppercase

                                                                                                                                                                                                                                                                                                                                                uppercase: () => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be all uppercase. If the validation convert option is on (enabled by default), the string will be forced to uppercase.

                                                                                                                                                                                                                                                                                                                                                method uri

                                                                                                                                                                                                                                                                                                                                                uri: (options?: UriOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid RFC 3986 URI.

                                                                                                                                                                                                                                                                                                                                                method uuid

                                                                                                                                                                                                                                                                                                                                                uuid: (options?: GuidOptions) => this;
                                                                                                                                                                                                                                                                                                                                                • Requires the string value to be a valid GUID.

                                                                                                                                                                                                                                                                                                                                                interface SwitchCases

                                                                                                                                                                                                                                                                                                                                                interface SwitchCases {}

                                                                                                                                                                                                                                                                                                                                                  property is

                                                                                                                                                                                                                                                                                                                                                  is: SchemaLike;
                                                                                                                                                                                                                                                                                                                                                  • the required condition joi type.

                                                                                                                                                                                                                                                                                                                                                  property then

                                                                                                                                                                                                                                                                                                                                                  then: SchemaLike;
                                                                                                                                                                                                                                                                                                                                                  • the alternative schema type if the condition is true.

                                                                                                                                                                                                                                                                                                                                                  interface SwitchDefault

                                                                                                                                                                                                                                                                                                                                                  interface SwitchDefault {}

                                                                                                                                                                                                                                                                                                                                                    property otherwise

                                                                                                                                                                                                                                                                                                                                                    otherwise: SchemaLike;
                                                                                                                                                                                                                                                                                                                                                    • the alternative schema type if no cases matched. Only one otherwise statement is allowed in switch as the last array item.

                                                                                                                                                                                                                                                                                                                                                    interface SymbolSchema

                                                                                                                                                                                                                                                                                                                                                    interface SymbolSchema extends AnySchema {}

                                                                                                                                                                                                                                                                                                                                                      method map

                                                                                                                                                                                                                                                                                                                                                      map: (
                                                                                                                                                                                                                                                                                                                                                      iterable:
                                                                                                                                                                                                                                                                                                                                                      | Iterable<[string | number | boolean | symbol, symbol]>
                                                                                                                                                                                                                                                                                                                                                      | { [key: string]: symbol }
                                                                                                                                                                                                                                                                                                                                                      ) => this;

                                                                                                                                                                                                                                                                                                                                                        interface TopLevelDomainOptions

                                                                                                                                                                                                                                                                                                                                                        interface TopLevelDomainOptions {}

                                                                                                                                                                                                                                                                                                                                                          property allow

                                                                                                                                                                                                                                                                                                                                                          allow?: Set<string> | string[] | boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                          • - true to use the IANA list of registered TLDs. This is the default value. - false to allow any TLD not listed in the deny list, if present. - A Set or array of the allowed TLDs. Cannot be used together with deny.

                                                                                                                                                                                                                                                                                                                                                          property deny

                                                                                                                                                                                                                                                                                                                                                          deny?: Set<string> | string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                          • - A Set or array of the forbidden TLDs. Cannot be used together with a custom allow list.

                                                                                                                                                                                                                                                                                                                                                          interface UriOptions

                                                                                                                                                                                                                                                                                                                                                          interface UriOptions {}

                                                                                                                                                                                                                                                                                                                                                            property allowQuerySquareBrackets

                                                                                                                                                                                                                                                                                                                                                            allowQuerySquareBrackets?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                            • Allows unencoded square brackets inside the query string. This is NOT RFC 3986 compliant but query strings like abc[]=123&abc[]=456 are very common these days.

                                                                                                                                                                                                                                                                                                                                                              false

                                                                                                                                                                                                                                                                                                                                                            property allowRelative

                                                                                                                                                                                                                                                                                                                                                            allowRelative?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                            • Allow relative URIs.

                                                                                                                                                                                                                                                                                                                                                              false

                                                                                                                                                                                                                                                                                                                                                            property domain

                                                                                                                                                                                                                                                                                                                                                            domain?: DomainOptions | undefined;
                                                                                                                                                                                                                                                                                                                                                            • Validate the domain component using the options specified in string.domain().

                                                                                                                                                                                                                                                                                                                                                            property relativeOnly

                                                                                                                                                                                                                                                                                                                                                            relativeOnly?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                            • Restrict only relative URIs.

                                                                                                                                                                                                                                                                                                                                                              false

                                                                                                                                                                                                                                                                                                                                                            property scheme

                                                                                                                                                                                                                                                                                                                                                            scheme?: string | RegExp | Array<string | RegExp> | undefined;
                                                                                                                                                                                                                                                                                                                                                            • Specifies one or more acceptable Schemes, should only include the scheme name. Can be an Array or String (strings are automatically escaped for use in a Regular Expression).

                                                                                                                                                                                                                                                                                                                                                            interface ValidationError

                                                                                                                                                                                                                                                                                                                                                            interface ValidationError extends Error {}

                                                                                                                                                                                                                                                                                                                                                              property details

                                                                                                                                                                                                                                                                                                                                                              details: ValidationErrorItem[];
                                                                                                                                                                                                                                                                                                                                                              • array of errors.

                                                                                                                                                                                                                                                                                                                                                              property isJoi

                                                                                                                                                                                                                                                                                                                                                              isJoi: boolean;

                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                name: 'ValidationError';

                                                                                                                                                                                                                                                                                                                                                                  method annotate

                                                                                                                                                                                                                                                                                                                                                                  annotate: (stripColors?: boolean) => string;
                                                                                                                                                                                                                                                                                                                                                                  • function that returns a string with an annotated version of the object pointing at the places where errors occurred.

                                                                                                                                                                                                                                                                                                                                                                    NOTE: This method does not exist in browser builds of Joi

                                                                                                                                                                                                                                                                                                                                                                    Parameter stripColors

                                                                                                                                                                                                                                                                                                                                                                    if truthy, will strip the colors out of the output.

                                                                                                                                                                                                                                                                                                                                                                  interface ValidationErrorItem

                                                                                                                                                                                                                                                                                                                                                                  interface ValidationErrorItem {}

                                                                                                                                                                                                                                                                                                                                                                    property context

                                                                                                                                                                                                                                                                                                                                                                    context?: Context | undefined;

                                                                                                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                                                                                                      message: string;

                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                        path: Array<string | number>;

                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                                                                                                            interface ValidationOptions

                                                                                                                                                                                                                                                                                                                                                                            interface ValidationOptions extends BaseValidationOptions {}

                                                                                                                                                                                                                                                                                                                                                                              property messages

                                                                                                                                                                                                                                                                                                                                                                              messages?: LanguageMessages | undefined;
                                                                                                                                                                                                                                                                                                                                                                              • overrides individual error messages. Defaults to no override ({}). Messages use the same rules as templates. Variables in double braces {{var}} are HTML escaped if the option errors.escapeHtml is set to true.

                                                                                                                                                                                                                                                                                                                                                                                {}

                                                                                                                                                                                                                                                                                                                                                                              interface ValidationResult

                                                                                                                                                                                                                                                                                                                                                                              interface ValidationResult {}

                                                                                                                                                                                                                                                                                                                                                                                property error

                                                                                                                                                                                                                                                                                                                                                                                error?: ValidationError | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property errors

                                                                                                                                                                                                                                                                                                                                                                                  errors?: ValidationError | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                    value: any;

                                                                                                                                                                                                                                                                                                                                                                                      property warning

                                                                                                                                                                                                                                                                                                                                                                                      warning?: ValidationError | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        interface WhenOptions

                                                                                                                                                                                                                                                                                                                                                                                        interface WhenOptions {}

                                                                                                                                                                                                                                                                                                                                                                                          property break

                                                                                                                                                                                                                                                                                                                                                                                          break?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • whether to stop applying further conditions if the condition is true.

                                                                                                                                                                                                                                                                                                                                                                                          property is

                                                                                                                                                                                                                                                                                                                                                                                          is?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • the required condition joi type.

                                                                                                                                                                                                                                                                                                                                                                                          property not

                                                                                                                                                                                                                                                                                                                                                                                          not?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • the negative version of is (then and otherwise have reverse roles).

                                                                                                                                                                                                                                                                                                                                                                                          property otherwise

                                                                                                                                                                                                                                                                                                                                                                                          otherwise?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • the alternative schema type if the condition is false. Required if then or switch are missing.

                                                                                                                                                                                                                                                                                                                                                                                          property switch

                                                                                                                                                                                                                                                                                                                                                                                          switch?: Array<SwitchCases | SwitchDefault> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • the list of cases. Required if then is missing. Required if then or otherwise are missing.

                                                                                                                                                                                                                                                                                                                                                                                          property then

                                                                                                                                                                                                                                                                                                                                                                                          then?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                          • the alternative schema type if the condition is true. Required if otherwise or switch are missing.

                                                                                                                                                                                                                                                                                                                                                                                          interface WhenSchemaOptions

                                                                                                                                                                                                                                                                                                                                                                                          interface WhenSchemaOptions {}

                                                                                                                                                                                                                                                                                                                                                                                            property otherwise

                                                                                                                                                                                                                                                                                                                                                                                            otherwise?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                            • the alternative schema type if the condition is false. Required if then is missing.

                                                                                                                                                                                                                                                                                                                                                                                            property then

                                                                                                                                                                                                                                                                                                                                                                                            then?: SchemaLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                            • the alternative schema type if the condition is true. Required if otherwise is missing.

                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                            type BasicType

                                                                                                                                                                                                                                                                                                                                                                                            type BasicType = boolean | number | string | any[] | object | null;

                                                                                                                                                                                                                                                                                                                                                                                              type CoerceFunction

                                                                                                                                                                                                                                                                                                                                                                                              type CoerceFunction = (value: any, helpers: CustomHelpers) => CoerceResult;

                                                                                                                                                                                                                                                                                                                                                                                                type ComparatorFunction

                                                                                                                                                                                                                                                                                                                                                                                                type ComparatorFunction = (a: any, b: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  type CustomValidator

                                                                                                                                                                                                                                                                                                                                                                                                  type CustomValidator<V = any> = (value: V, helpers: CustomHelpers) => V;

                                                                                                                                                                                                                                                                                                                                                                                                    type ExtensionBoundSchema

                                                                                                                                                                                                                                                                                                                                                                                                    type ExtensionBoundSchema = Schema & SchemaInternals;

                                                                                                                                                                                                                                                                                                                                                                                                      type ExtensionFactory

                                                                                                                                                                                                                                                                                                                                                                                                      type ExtensionFactory = (joi: Root) => Extension;

                                                                                                                                                                                                                                                                                                                                                                                                        type ExternalValidationFunction

                                                                                                                                                                                                                                                                                                                                                                                                        type ExternalValidationFunction = (value: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                          type GuidVersions

                                                                                                                                                                                                                                                                                                                                                                                                          type GuidVersions = 'uuidv1' | 'uuidv2' | 'uuidv3' | 'uuidv4' | 'uuidv5';

                                                                                                                                                                                                                                                                                                                                                                                                            type LanguageMessages

                                                                                                                                                                                                                                                                                                                                                                                                            type LanguageMessages = Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                              type PresenceMode

                                                                                                                                                                                                                                                                                                                                                                                                              type PresenceMode = 'optional' | 'required' | 'forbidden';

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleMethod

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleMethod = (...args: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                  type Schema

                                                                                                                                                                                                                                                                                                                                                                                                                  type Schema =
                                                                                                                                                                                                                                                                                                                                                                                                                  | AnySchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | ArraySchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | AlternativesSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | BinarySchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | BooleanSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | DateSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | FunctionSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | NumberSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | ObjectSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | StringSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | LinkSchema
                                                                                                                                                                                                                                                                                                                                                                                                                  | SymbolSchema;

                                                                                                                                                                                                                                                                                                                                                                                                                    type SchemaFunction

                                                                                                                                                                                                                                                                                                                                                                                                                    type SchemaFunction = (schema: Schema) => Schema;

                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaLike

                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaLike = string | number | boolean | object | null | Schema | SchemaMap;

                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaMap

                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaMap<TSchema = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                        [key in keyof TSchema]?: SchemaLike | SchemaLike[];
                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                          type Types

                                                                                                                                                                                                                                                                                                                                                                                                                          type Types =
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'any'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'alternatives'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'array'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'boolean'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'binary'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'date'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'function'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'link'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'number'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'object'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'string'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'symbol';

                                                                                                                                                                                                                                                                                                                                                                                                                            type ValidationErrorFunction

                                                                                                                                                                                                                                                                                                                                                                                                                            type ValidationErrorFunction = (
                                                                                                                                                                                                                                                                                                                                                                                                                            errors: ErrorReport[]
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => string | ValidationErrorItem | Error;

                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/hapi__joi.

                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/hapi__joi)
                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@types/hapi__joi"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>