Class ParseErrors

constructor

• new ParseErrors(): ParseErrors

  Returns ParseErrors

Static Readonlyarray

Static Readonlyboolean

Static Readonlycomplex

Static Readonlydate

Static Readonlydictionary

Static Readonlyempty

Static Readonlyfloat

Static Readonlyint

Static Readonlyjson

Static Readonlyrequired

Static Readonlystring

Static Readonlyunique

Static ReadonlyanyOf

• anyOf<T>(
      values: NumberEnumMap | T[],
      ignoreCase?: boolean,
  ): { anyOf: { ignoreCase: boolean; value: (string | number)[] | T[] } }

  value should be equal to any of the values, ignoreCase only valid for string

  Type Parameters

  • T

  Parameters

  • values: NumberEnumMap | T[]
  • OptionalignoreCase: boolean

  Returns { anyOf: { ignoreCase: boolean; value: (string | number)[] | T[] } }

Static ReadonlyendsWith

• endsWith<T>(
      value: T,
      ignoreCase?: boolean,
  ): { endsWith: { ignoreCase: boolean; value: T } }

  ends with

  Type Parameters

  • T

  Parameters

  • value: T
  • OptionalignoreCase: boolean

  Returns { endsWith: { ignoreCase: boolean; value: T } }

Static Readonlyequals

• equals<T>(
      value: T,
      ignoreCase?: boolean,
  ): { equals: { ignoreCase: boolean; value: T } }

  value should be equal to the value, ignoreCase only valid for string

  Type Parameters

  • T

  Parameters

  • value: T
  • OptionalignoreCase: boolean

  Returns { equals: { ignoreCase: boolean; value: T } }

Static Readonlyincludes

• includes<T>(
      value: T,
      ignoreCase?: boolean,
  ): { includes: { ignoreCase: boolean; value: T } }

  value includes

  Type Parameters

  • T

  Parameters

  • value: T
  • OptionalignoreCase: boolean

  Returns { includes: { ignoreCase: boolean; value: T } }

Static Readonlymatches

• matches<T>(name: T): { matches: T }

  value includes

  Type Parameters

  • T

  Parameters

  • name: T

  Returns { matches: T }

Static Readonlymax

• max<T>(value: T, exclusive?: boolean): { max: { exclusive: boolean; value: T } }

  value should be at most

  Type Parameters

  • T

  Parameters

  • value: T
  • exclusive: boolean = false

  Returns { max: { exclusive: boolean; value: T } }

Static ReadonlymaxLength

• maxLength<T>(
      value: T,
      exclusive?: boolean,
  ): { exclusive: boolean; maxLength: T }

  value length should be at most

  Type Parameters

  • T

  Parameters

  • value: T
  • exclusive: boolean = false

  Returns { exclusive: boolean; maxLength: T }

Static Readonlymin

• min<T>(value: T, exclusive?: boolean): { min: { exclusive: boolean; value: T } }

  value should be at least

  Type Parameters

  • T

  Parameters

  • value: T
  • exclusive: boolean = false

  Returns { min: { exclusive: boolean; value: T } }

Static ReadonlyminLength

• minLength<T>(
      value: T,
      exclusive?: boolean,
  ): { exclusive: boolean; minLength: T }

  value length should be at least

  Type Parameters

  • T

  Parameters

  • value: T
  • exclusive: boolean = false

  Returns { exclusive: boolean; minLength: T }

Static Readonlynot

• not<T>(value: T): { not: T }

  wrap error in a not

  Type Parameters

  • T

  Parameters

  • value: T

  Returns { not: T }

Static ReadonlystartsWith

• startsWith<T>(
      value: T,
      ignoreCase?: boolean,
  ): { startsWith: { ignoreCase: boolean; value: T } }

  starts with

  Type Parameters

  • T

  Parameters

  • value: T
  • OptionalignoreCase: boolean

  Returns { startsWith: { ignoreCase: boolean; value: T } }