ajv

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

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

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

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

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

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

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

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

else: () => CodeGen;

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

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

endFor: () => CodeGen;

endFunc: () => CodeGen;

endIf: () => CodeGen;

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

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

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

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

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

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

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

label: (label: Name) => CodeGen;

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

name: (prefix: string) => Name;

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

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

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

scopeCode: () => Code;

scopeName: (prefix: string) => ValueScopeName;

scopeRefs: (scopeName: Name) => Code;

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

throw: (error: Code) => CodeGen;

toString: () => string;

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

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

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

readonly $data?: string | false;

readonly allErrors?: boolean;

readonly data: Name;

readonly def: AddedKeywordDefinition;

readonly errsCount?: Name;

readonly gen: CodeGen;

readonly it: SchemaObjCxt;

readonly keyword: string;

params: KeywordCxtParams;

readonly parentSchema: AnySchemaObject;

schema: any;

readonly schemaCode: number | boolean | Code;

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

readonly schemaValue: number | boolean | Code;

$dataError: () => void;

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

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

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

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

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

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

invalid$data: () => Code;

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

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

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

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

reset: () => void;

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

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

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

constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string);

readonly missingRef: string;

readonly missingSchema: string;

constructor(s: string);

readonly names: UsedNames;

readonly str: string;

emptyStr: () => boolean;

toString: () => string;

constructor(
    errors: Partial<ErrorObject<string, Record<string, any>, unknown>>[]
);

readonly ajv: boolean;

readonly errors: Partial<ErrorObject<string, Record<string, any>, unknown>>[];

readonly validation: boolean;

async: true;

compare?: FormatCompare<T>;

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

validate: AsyncFormatValidator<T>;

$async: true;

$async: true;

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

es5?: boolean;

lines?: boolean;

ownProperties?: boolean;

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

trackErrors?: boolean;

es5?: boolean;

esm?: boolean;

formats?: Code;

lines?: boolean;

optimize?: boolean | number;

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

regExp?: RegExpEngine;

source?: boolean;

data?: unknown;

instancePath: string;

keyword: K;

message?: string;

params: P;

parentSchema?: AnySchemaObject;

propertyName?: string;

schema?: S;

schemaPath: string;

dataVar?: string;

separator?: string;

async?: false | undefined;

compare?: FormatCompare<T>;

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

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

async?: boolean;

compile?: CompileKeywordFunc;

errors?: boolean | 'full';

modifying?: boolean;

schema?: boolean;

valid?: boolean;

validate?: SchemaValidateFunction | DataValidateFunction;

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

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

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

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

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

macro: MacroKeywordFunc;

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

[prop: string]: any;

readonly allErrors?: boolean;

baseId: string;

readonly compositeRule?: boolean;

readonly createErrors?: boolean;

readonly data: Name;

readonly dataLevel: number;

readonly dataNames: Name[];

readonly dataPathArr: (Code | number)[];

dataTypes: JSONType[];

definedProperties: Set<string>;

readonly errorPath: Code;

readonly errSchemaPath: string;

evaluated?: Name;

readonly gen: CodeGen;

items?: EvaluatedItems | Name;

jtdDiscriminator?: string;

jtdMetadata?: boolean;

readonly opts: InstanceOptions;

readonly parentData: Name;

readonly parentDataProperty: Code | number;

readonly propertyName?: Name;

props?: EvaluatedProperties | Name;

readonly rootId: string;

readonly schema: AnySchema;

readonly schemaEnv: SchemaEnv;

readonly schemaPath: Code;

readonly self: Ajv;

readonly topSchemaRef: Code;

readonly validateName: Name;

readonly ValidationError?: Name;

readonly schema: AnySchemaObject;

$async?: false;

$id?: string;

$schema?: string;

id?: string;

[x: string]: any;

errors?: Partial<ErrorObject>[];

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

errors?: null | ErrorObject[];

evaluated?: Evaluated;

schema: AnySchema;

schemaEnv: SchemaEnv;

source?: SourceCode;

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