ajv

  • Version 8.6.0
  • Published
  • 997 kB
  • 4 dependencies
  • MIT license

Install

npm i ajv
yarn add ajv
pnpm add ajv

Overview

Another JSON Schema Validator

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable nil

const nil: _Code;

    Functions

    function str

    str: (strs: TemplateStringsArray, ...args: (CodeArg | string[])[]) => _Code;

      function stringify

      stringify: (x: unknown) => Code;

        Classes

        class Ajv

        class Ajv extends AjvCore {}

          method defaultMeta

          defaultMeta: () => string | AnySchemaObject | undefined;

            class CodeGen

            class CodeGen {}

              constructor

              constructor(extScope: ValueScope, opts?: CodeGenOptions);

                method add

                add: (lhs: Code, rhs: SafeExpr) => CodeGen;

                  method assign

                  assign: (lhs: Code, rhs: SafeExpr, sideEffects?: boolean) => CodeGen;

                    method block

                    block: (body?: Block, nodeCount?: number) => CodeGen;

                      method break

                      break: (label?: Code) => CodeGen;

                        method code

                        code: (c: Block | SafeExpr) => CodeGen;

                          method const

                          const: (nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean) => Name;

                            method else

                            else: () => CodeGen;

                              method elseIf

                              elseIf: (condition: Code | boolean) => CodeGen;

                                method endBlock

                                endBlock: (nodeCount?: number) => CodeGen;

                                  method endFor

                                  endFor: () => CodeGen;

                                    method endFunc

                                    endFunc: () => CodeGen;

                                      method endIf

                                      endIf: () => CodeGen;

                                        method for

                                        for: (iteration: Code, forBody?: Block) => CodeGen;

                                          method forIn

                                          forIn: (
                                          nameOrPrefix: Name | string,
                                          obj: Code,
                                          forBody: (item: Name) => void,
                                          varKind?: Code
                                          ) => CodeGen;

                                            method forOf

                                            forOf: (
                                            nameOrPrefix: Name | string,
                                            iterable: Code,
                                            forBody: (item: Name) => void,
                                            varKind?: Code
                                            ) => CodeGen;

                                              method forRange

                                              forRange: (
                                              nameOrPrefix: Name | string,
                                              from: SafeExpr,
                                              to: SafeExpr,
                                              forBody: (index: Name) => void,
                                              varKind?: Code
                                              ) => CodeGen;

                                                method func

                                                func: (name: Name, args?: Code, async?: boolean, funcBody?: Block) => CodeGen;

                                                  method getScopeValue

                                                  getScopeValue: (prefix: string, keyOrRef: unknown) => ValueScopeName | undefined;

                                                    method if

                                                    if: (condition: Code | boolean, thenBody?: Block, elseBody?: Block) => CodeGen;

                                                      method label

                                                      label: (label: Name) => CodeGen;

                                                        method let

                                                        let: (nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean) => Name;

                                                          method name

                                                          name: (prefix: string) => Name;

                                                            method object

                                                            object: (...keyValues: [Name | string, SafeExpr | string][]) => _Code;

                                                              method optimize

                                                              optimize: (n?: number) => void;

                                                                method return

                                                                return: (value: Block | SafeExpr) => CodeGen;

                                                                  method scopeCode

                                                                  scopeCode: () => Code;

                                                                    method scopeName

                                                                    scopeName: (prefix: string) => ValueScopeName;

                                                                      method scopeRefs

                                                                      scopeRefs: (scopeName: Name) => Code;

                                                                        method scopeValue

                                                                        scopeValue: (prefixOrName: ValueScopeName | string, value: NameValue) => Name;

                                                                          method throw

                                                                          throw: (error: Code) => CodeGen;

                                                                            method toString

                                                                            toString: () => string;

                                                                              method try

                                                                              try: (
                                                                              tryBody: Block,
                                                                              catchCode?: (e: Name) => void,
                                                                              finallyCode?: Block
                                                                              ) => CodeGen;

                                                                                method var

                                                                                var: (nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean) => Name;

                                                                                  class KeywordCxt

                                                                                  class KeywordCxt implements KeywordErrorCxt {}

                                                                                    constructor

                                                                                    constructor(it: SchemaObjCxt, def: AddedKeywordDefinition, keyword: string);

                                                                                      property $data

                                                                                      readonly $data?: string | false;

                                                                                        property allErrors

                                                                                        readonly allErrors?: boolean;

                                                                                          property data

                                                                                          readonly data: Name;

                                                                                            property def

                                                                                            readonly def: AddedKeywordDefinition;

                                                                                              property errsCount

                                                                                              readonly errsCount?: Name;

                                                                                                property gen

                                                                                                readonly gen: CodeGen;

                                                                                                  property it

                                                                                                  readonly it: SchemaObjCxt;

                                                                                                    property keyword

                                                                                                    readonly keyword: string;

                                                                                                      property params

                                                                                                      params: KeywordCxtParams;

                                                                                                        property parentSchema

                                                                                                        readonly parentSchema: AnySchemaObject;

                                                                                                          property schema

                                                                                                          schema: any;

                                                                                                            property schemaCode

                                                                                                            readonly schemaCode: number | boolean | Code;

                                                                                                              property schemaType

                                                                                                              readonly schemaType: (
                                                                                                              | 'string'
                                                                                                              | 'number'
                                                                                                              | 'boolean'
                                                                                                              | 'object'
                                                                                                              | 'integer'
                                                                                                              | 'null'
                                                                                                              | 'array'
                                                                                                              )[];

                                                                                                                property schemaValue

                                                                                                                readonly schemaValue: number | boolean | Code;

                                                                                                                  method $dataError

                                                                                                                  $dataError: () => void;

                                                                                                                    method block$data

                                                                                                                    block$data: (valid: Name, codeBlock: () => void, $dataValid?: Code) => void;

                                                                                                                      method check$data

                                                                                                                      check$data: (valid?: Name, $dataValid?: Code) => void;

                                                                                                                        method error

                                                                                                                        error: (
                                                                                                                        append?: boolean,
                                                                                                                        errorParams?: KeywordCxtParams,
                                                                                                                        errorPaths?: ErrorPaths
                                                                                                                        ) => void;

                                                                                                                          method fail

                                                                                                                          fail: (condition?: Code) => void;

                                                                                                                            method fail$data

                                                                                                                            fail$data: (condition: Code) => void;

                                                                                                                              method invalid$data

                                                                                                                              invalid$data: () => Code;

                                                                                                                                method mergeEvaluated

                                                                                                                                mergeEvaluated: (schemaCxt: SchemaCxt, toName?: typeof Name) => void;

                                                                                                                                  method mergeValidEvaluated

                                                                                                                                  mergeValidEvaluated: (schemaCxt: SchemaCxt, valid: Name) => boolean | void;

                                                                                                                                    method ok

                                                                                                                                    ok: (cond: Code | boolean) => void;

                                                                                                                                      method pass

                                                                                                                                      pass: (condition: Code, failAction?: () => void) => void;

                                                                                                                                        method reset

                                                                                                                                        reset: () => void;

                                                                                                                                          method result

                                                                                                                                          result: (
                                                                                                                                          condition: Code,
                                                                                                                                          successAction?: () => void,
                                                                                                                                          failAction?: () => void
                                                                                                                                          ) => void;

                                                                                                                                            method setParams

                                                                                                                                            setParams: (obj: KeywordCxtParams, assign?: true) => void;

                                                                                                                                              method subschema

                                                                                                                                              subschema: (appl: SubschemaArgs, valid: Name) => SchemaCxt;

                                                                                                                                                class Name

                                                                                                                                                class Name extends _CodeOrName {}

                                                                                                                                                  constructor

                                                                                                                                                  constructor(s: string);

                                                                                                                                                    property names

                                                                                                                                                    readonly names: UsedNames;

                                                                                                                                                      property str

                                                                                                                                                      readonly str: string;

                                                                                                                                                        method emptyStr

                                                                                                                                                        emptyStr: () => boolean;

                                                                                                                                                          method toString

                                                                                                                                                          toString: () => string;

                                                                                                                                                            Interfaces

                                                                                                                                                            interface AsyncFormatDefinition

                                                                                                                                                            interface AsyncFormatDefinition<T extends string | number> {}

                                                                                                                                                              property async

                                                                                                                                                              async: true;

                                                                                                                                                                property compare

                                                                                                                                                                compare?: FormatCompare<T>;

                                                                                                                                                                  property type

                                                                                                                                                                  type?: T extends string ? 'string' | undefined : 'number';

                                                                                                                                                                    property validate

                                                                                                                                                                    validate: AsyncFormatValidator<T>;

                                                                                                                                                                      interface AsyncSchema

                                                                                                                                                                      interface AsyncSchema extends _SchemaObject {}

                                                                                                                                                                        property $async

                                                                                                                                                                        $async: true;

                                                                                                                                                                          interface AsyncValidateFunction

                                                                                                                                                                          interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {}

                                                                                                                                                                            property $async

                                                                                                                                                                            $async: true;

                                                                                                                                                                              call signature

                                                                                                                                                                              (...args: Parameters<ValidateFunction<T>>): Promise<T>;

                                                                                                                                                                                interface CodeGenOptions

                                                                                                                                                                                interface CodeGenOptions {}

                                                                                                                                                                                  property es5

                                                                                                                                                                                  es5?: boolean;

                                                                                                                                                                                    property lines

                                                                                                                                                                                    lines?: boolean;

                                                                                                                                                                                      property ownProperties

                                                                                                                                                                                      ownProperties?: boolean;

                                                                                                                                                                                        interface CodeKeywordDefinition

                                                                                                                                                                                        interface CodeKeywordDefinition extends _KeywordDef {}

                                                                                                                                                                                          property code

                                                                                                                                                                                          code: (cxt: KeywordCxt, ruleType?: string) => void;

                                                                                                                                                                                            property trackErrors

                                                                                                                                                                                            trackErrors?: boolean;

                                                                                                                                                                                              interface CodeOptions

                                                                                                                                                                                              interface CodeOptions {}

                                                                                                                                                                                                property es5

                                                                                                                                                                                                es5?: boolean;

                                                                                                                                                                                                  property formats

                                                                                                                                                                                                  formats?: Code;

                                                                                                                                                                                                    property lines

                                                                                                                                                                                                    lines?: boolean;

                                                                                                                                                                                                      property optimize

                                                                                                                                                                                                      optimize?: boolean | number;

                                                                                                                                                                                                        property process

                                                                                                                                                                                                        process?: (code: string, schema?: SchemaEnv) => string;

                                                                                                                                                                                                          property source

                                                                                                                                                                                                          source?: boolean;

                                                                                                                                                                                                            interface ErrorObject

                                                                                                                                                                                                            interface ErrorObject<
                                                                                                                                                                                                            K extends string = string,
                                                                                                                                                                                                            P = Record<string, any>,
                                                                                                                                                                                                            S = unknown
                                                                                                                                                                                                            > {}

                                                                                                                                                                                                              property data

                                                                                                                                                                                                              data?: unknown;

                                                                                                                                                                                                                property instancePath

                                                                                                                                                                                                                instancePath: string;

                                                                                                                                                                                                                  property keyword

                                                                                                                                                                                                                  keyword: K;

                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                    message?: string;

                                                                                                                                                                                                                      property params

                                                                                                                                                                                                                      params: P;

                                                                                                                                                                                                                        property parentSchema

                                                                                                                                                                                                                        parentSchema?: AnySchemaObject;

                                                                                                                                                                                                                          property propertyName

                                                                                                                                                                                                                          propertyName?: string;

                                                                                                                                                                                                                            property schema

                                                                                                                                                                                                                            schema?: S;

                                                                                                                                                                                                                              property schemaPath

                                                                                                                                                                                                                              schemaPath: string;

                                                                                                                                                                                                                                interface ErrorsTextOptions

                                                                                                                                                                                                                                interface ErrorsTextOptions {}

                                                                                                                                                                                                                                  property dataVar

                                                                                                                                                                                                                                  dataVar?: string;

                                                                                                                                                                                                                                    property separator

                                                                                                                                                                                                                                    separator?: string;

                                                                                                                                                                                                                                      interface FormatDefinition

                                                                                                                                                                                                                                      interface FormatDefinition<T extends string | number> {}

                                                                                                                                                                                                                                        property async

                                                                                                                                                                                                                                        async?: false | undefined;

                                                                                                                                                                                                                                          property compare

                                                                                                                                                                                                                                          compare?: FormatCompare<T>;

                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                            type?: T extends string ? 'string' | undefined : 'number';

                                                                                                                                                                                                                                              property validate

                                                                                                                                                                                                                                              validate: FormatValidator<T> | (T extends string ? string | RegExp : never);

                                                                                                                                                                                                                                                interface FuncKeywordDefinition

                                                                                                                                                                                                                                                interface FuncKeywordDefinition extends _KeywordDef {}

                                                                                                                                                                                                                                                  property async

                                                                                                                                                                                                                                                  async?: boolean;

                                                                                                                                                                                                                                                    property compile

                                                                                                                                                                                                                                                    compile?: CompileKeywordFunc;

                                                                                                                                                                                                                                                      property errors

                                                                                                                                                                                                                                                      errors?: boolean | 'full';

                                                                                                                                                                                                                                                        property modifying

                                                                                                                                                                                                                                                        modifying?: boolean;

                                                                                                                                                                                                                                                          property schema

                                                                                                                                                                                                                                                          schema?: boolean;

                                                                                                                                                                                                                                                            property valid

                                                                                                                                                                                                                                                            valid?: boolean;

                                                                                                                                                                                                                                                              property validate

                                                                                                                                                                                                                                                              validate?: SchemaValidateFunction | DataValidateFunction;

                                                                                                                                                                                                                                                                interface KeywordErrorDefinition

                                                                                                                                                                                                                                                                interface KeywordErrorDefinition {}

                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                  message: string | Code | ((cxt: KeywordErrorCxt) => string | Code);

                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                    params?: Code | ((cxt: KeywordErrorCxt) => Code);

                                                                                                                                                                                                                                                                      interface Logger

                                                                                                                                                                                                                                                                      interface Logger {}

                                                                                                                                                                                                                                                                        method error

                                                                                                                                                                                                                                                                        error: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                          method log

                                                                                                                                                                                                                                                                          log: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                            method warn

                                                                                                                                                                                                                                                                            warn: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                              interface MacroKeywordDefinition

                                                                                                                                                                                                                                                                              interface MacroKeywordDefinition extends FuncKeywordDefinition {}

                                                                                                                                                                                                                                                                                property macro

                                                                                                                                                                                                                                                                                macro: MacroKeywordFunc;

                                                                                                                                                                                                                                                                                  interface Plugin

                                                                                                                                                                                                                                                                                  interface Plugin<Opts> {}

                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                    (ajv: Ajv, options?: Opts): Ajv;

                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                      [prop: string]: any;

                                                                                                                                                                                                                                                                                        interface SchemaCxt

                                                                                                                                                                                                                                                                                        interface SchemaCxt {}

                                                                                                                                                                                                                                                                                          property allErrors

                                                                                                                                                                                                                                                                                          readonly allErrors?: boolean;

                                                                                                                                                                                                                                                                                            property baseId

                                                                                                                                                                                                                                                                                            baseId: string;

                                                                                                                                                                                                                                                                                              property compositeRule

                                                                                                                                                                                                                                                                                              readonly compositeRule?: boolean;

                                                                                                                                                                                                                                                                                                property createErrors

                                                                                                                                                                                                                                                                                                readonly createErrors?: boolean;

                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                  readonly data: Name;

                                                                                                                                                                                                                                                                                                    property dataLevel

                                                                                                                                                                                                                                                                                                    readonly dataLevel: number;

                                                                                                                                                                                                                                                                                                      property dataNames

                                                                                                                                                                                                                                                                                                      readonly dataNames: Name[];

                                                                                                                                                                                                                                                                                                        property dataPathArr

                                                                                                                                                                                                                                                                                                        readonly dataPathArr: (Code | number)[];

                                                                                                                                                                                                                                                                                                          property dataTypes

                                                                                                                                                                                                                                                                                                          dataTypes: JSONType[];

                                                                                                                                                                                                                                                                                                            property definedProperties

                                                                                                                                                                                                                                                                                                            definedProperties: Set<string>;

                                                                                                                                                                                                                                                                                                              property errorPath

                                                                                                                                                                                                                                                                                                              readonly errorPath: Code;

                                                                                                                                                                                                                                                                                                                property errSchemaPath

                                                                                                                                                                                                                                                                                                                readonly errSchemaPath: string;

                                                                                                                                                                                                                                                                                                                  property evaluated

                                                                                                                                                                                                                                                                                                                  evaluated?: Name;

                                                                                                                                                                                                                                                                                                                    property gen

                                                                                                                                                                                                                                                                                                                    readonly gen: CodeGen;

                                                                                                                                                                                                                                                                                                                      property items

                                                                                                                                                                                                                                                                                                                      items?: EvaluatedItems | Name;

                                                                                                                                                                                                                                                                                                                        property jtdDiscriminator

                                                                                                                                                                                                                                                                                                                        jtdDiscriminator?: string;

                                                                                                                                                                                                                                                                                                                          property jtdMetadata

                                                                                                                                                                                                                                                                                                                          jtdMetadata?: boolean;

                                                                                                                                                                                                                                                                                                                            property opts

                                                                                                                                                                                                                                                                                                                            readonly opts: InstanceOptions;

                                                                                                                                                                                                                                                                                                                              property parentData

                                                                                                                                                                                                                                                                                                                              readonly parentData: Name;

                                                                                                                                                                                                                                                                                                                                property parentDataProperty

                                                                                                                                                                                                                                                                                                                                readonly parentDataProperty: Code | number;

                                                                                                                                                                                                                                                                                                                                  property propertyName

                                                                                                                                                                                                                                                                                                                                  readonly propertyName?: Name;

                                                                                                                                                                                                                                                                                                                                    property props

                                                                                                                                                                                                                                                                                                                                    props?: EvaluatedProperties | Name;

                                                                                                                                                                                                                                                                                                                                      property rootId

                                                                                                                                                                                                                                                                                                                                      readonly rootId: string;

                                                                                                                                                                                                                                                                                                                                        property schema

                                                                                                                                                                                                                                                                                                                                        readonly schema: AnySchema;

                                                                                                                                                                                                                                                                                                                                          property schemaEnv

                                                                                                                                                                                                                                                                                                                                          readonly schemaEnv: SchemaEnv;

                                                                                                                                                                                                                                                                                                                                            property schemaPath

                                                                                                                                                                                                                                                                                                                                            readonly schemaPath: Code;

                                                                                                                                                                                                                                                                                                                                              property self

                                                                                                                                                                                                                                                                                                                                              readonly self: Ajv;

                                                                                                                                                                                                                                                                                                                                                property topSchemaRef

                                                                                                                                                                                                                                                                                                                                                readonly topSchemaRef: Code;

                                                                                                                                                                                                                                                                                                                                                  property validateName

                                                                                                                                                                                                                                                                                                                                                  readonly validateName: Name;

                                                                                                                                                                                                                                                                                                                                                    property ValidationError

                                                                                                                                                                                                                                                                                                                                                    readonly ValidationError?: Name;

                                                                                                                                                                                                                                                                                                                                                      interface SchemaObjCxt

                                                                                                                                                                                                                                                                                                                                                      interface SchemaObjCxt extends SchemaCxt {}

                                                                                                                                                                                                                                                                                                                                                        property schema

                                                                                                                                                                                                                                                                                                                                                        readonly schema: AnySchemaObject;

                                                                                                                                                                                                                                                                                                                                                          interface SchemaObject

                                                                                                                                                                                                                                                                                                                                                          interface SchemaObject extends _SchemaObject {}

                                                                                                                                                                                                                                                                                                                                                            property $async

                                                                                                                                                                                                                                                                                                                                                            $async?: false;

                                                                                                                                                                                                                                                                                                                                                              property $id

                                                                                                                                                                                                                                                                                                                                                              $id?: string;

                                                                                                                                                                                                                                                                                                                                                                property $schema

                                                                                                                                                                                                                                                                                                                                                                $schema?: string;

                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                  id?: string;

                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                    [x: string]: any;

                                                                                                                                                                                                                                                                                                                                                                      interface SchemaValidateFunction

                                                                                                                                                                                                                                                                                                                                                                      interface SchemaValidateFunction {}

                                                                                                                                                                                                                                                                                                                                                                        property errors

                                                                                                                                                                                                                                                                                                                                                                        errors?: Partial<ErrorObject>[];

                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          schema: any,
                                                                                                                                                                                                                                                                                                                                                                          data: any,
                                                                                                                                                                                                                                                                                                                                                                          parentSchema?: AnySchemaObject,
                                                                                                                                                                                                                                                                                                                                                                          dataCxt?: DataValidationCxt
                                                                                                                                                                                                                                                                                                                                                                          ): boolean | Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                            interface ValidateFunction

                                                                                                                                                                                                                                                                                                                                                                            interface ValidateFunction<T = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                              property errors

                                                                                                                                                                                                                                                                                                                                                                              errors?: null | ErrorObject[];

                                                                                                                                                                                                                                                                                                                                                                                property evaluated

                                                                                                                                                                                                                                                                                                                                                                                evaluated?: Evaluated;

                                                                                                                                                                                                                                                                                                                                                                                  property schema

                                                                                                                                                                                                                                                                                                                                                                                  schema: AnySchema;

                                                                                                                                                                                                                                                                                                                                                                                    property schemaEnv

                                                                                                                                                                                                                                                                                                                                                                                    schemaEnv: SchemaEnv;

                                                                                                                                                                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                                                                                                                                                                      source?: SourceCode;

                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                        (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T;

                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                          type AnySchema

                                                                                                                                                                                                                                                                                                                                                                                          type AnySchema = Schema | AsyncSchema;

                                                                                                                                                                                                                                                                                                                                                                                            type AnySchemaObject

                                                                                                                                                                                                                                                                                                                                                                                            type AnySchemaObject = SchemaObject | AsyncSchema;

                                                                                                                                                                                                                                                                                                                                                                                              type Code

                                                                                                                                                                                                                                                                                                                                                                                              type Code = _Code | Name;

                                                                                                                                                                                                                                                                                                                                                                                                type DefinedError

                                                                                                                                                                                                                                                                                                                                                                                                type DefinedError =
                                                                                                                                                                                                                                                                                                                                                                                                | TypeError
                                                                                                                                                                                                                                                                                                                                                                                                | ApplicatorKeywordError
                                                                                                                                                                                                                                                                                                                                                                                                | ValidationKeywordError
                                                                                                                                                                                                                                                                                                                                                                                                | FormatError
                                                                                                                                                                                                                                                                                                                                                                                                | UnevaluatedPropertiesError
                                                                                                                                                                                                                                                                                                                                                                                                | UnevaluatedItemsError
                                                                                                                                                                                                                                                                                                                                                                                                | DependentRequiredError
                                                                                                                                                                                                                                                                                                                                                                                                | DiscriminatorError;

                                                                                                                                                                                                                                                                                                                                                                                                  type ErrorNoParams

                                                                                                                                                                                                                                                                                                                                                                                                  type ErrorNoParams<K extends string, S = unknown> = ErrorObject<
                                                                                                                                                                                                                                                                                                                                                                                                  K,
                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, never>,
                                                                                                                                                                                                                                                                                                                                                                                                  S
                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                    type Format

                                                                                                                                                                                                                                                                                                                                                                                                    type Format = AddedFormat | string;

                                                                                                                                                                                                                                                                                                                                                                                                      type InstanceOptions

                                                                                                                                                                                                                                                                                                                                                                                                      type InstanceOptions = Options & RequiredInstanceOptions;

                                                                                                                                                                                                                                                                                                                                                                                                        type JSONSchemaType

                                                                                                                                                                                                                                                                                                                                                                                                        type JSONSchemaType<T> = StrictNullChecksWrapper<
                                                                                                                                                                                                                                                                                                                                                                                                        'JSONSchemaType',
                                                                                                                                                                                                                                                                                                                                                                                                        UncheckedJSONSchemaType<T, false>
                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                          type JSONType

                                                                                                                                                                                                                                                                                                                                                                                                          type JSONType = typeof _jsonTypes[number];

                                                                                                                                                                                                                                                                                                                                                                                                            type KeywordDefinition

                                                                                                                                                                                                                                                                                                                                                                                                            type KeywordDefinition =
                                                                                                                                                                                                                                                                                                                                                                                                            | CodeKeywordDefinition
                                                                                                                                                                                                                                                                                                                                                                                                            | FuncKeywordDefinition
                                                                                                                                                                                                                                                                                                                                                                                                            | MacroKeywordDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                              type Options

                                                                                                                                                                                                                                                                                                                                                                                                              type Options = CurrentOptions & DeprecatedOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                type Schema

                                                                                                                                                                                                                                                                                                                                                                                                                type Schema = SchemaObject | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  type Vocabulary

                                                                                                                                                                                                                                                                                                                                                                                                                  type Vocabulary = (KeywordDefinition | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (10)

                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (4)

                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (39)

                                                                                                                                                                                                                                                                                                                                                                                                                    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/ajv.

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