File size: 8,325 Bytes
47b95f8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, AnyValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
export { SchemaCxt, SchemaObjCxt } from "./compile";
export interface Plugin<Opts> {
(ajv: Ajv, options?: Opts): Ajv;
[prop: string]: any;
}
export { KeywordCxt } from "./compile/validate";
export { DefinedError } from "./vocabularies/errors";
export { JSONType } from "./compile/rules";
export { JSONSchemaType } from "./types/json-schema";
export { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
import type { Schema, AnySchema, AnySchemaObject, SchemaObject, AsyncSchema, Vocabulary, KeywordDefinition, AddedKeywordDefinition, AnyValidateFunction, ValidateFunction, AsyncValidateFunction, ErrorObject, Format, AddedFormat, RegExpEngine, UriResolver } from "./types";
import type { JSONSchemaType } from "./types/json-schema";
import type { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
import ValidationError from "./runtime/validation_error";
import MissingRefError from "./compile/ref_error";
import { ValidationRules } from "./compile/rules";
import { SchemaEnv } from "./compile";
import { Code, ValueScope } from "./compile/codegen";
export type Options = CurrentOptions & DeprecatedOptions;
export interface CurrentOptions {
strict?: boolean | "log";
strictSchema?: boolean | "log";
strictNumbers?: boolean | "log";
strictTypes?: boolean | "log";
strictTuples?: boolean | "log";
strictRequired?: boolean | "log";
allowMatchingProperties?: boolean;
allowUnionTypes?: boolean;
validateFormats?: boolean;
$data?: boolean;
allErrors?: boolean;
verbose?: boolean;
discriminator?: boolean;
unicodeRegExp?: boolean;
timestamp?: "string" | "date";
parseDate?: boolean;
allowDate?: boolean;
specialNumbers?: "fast" | "null";
$comment?: true | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => unknown);
formats?: {
[Name in string]?: Format;
};
keywords?: Vocabulary;
schemas?: AnySchema[] | {
[Key in string]?: AnySchema;
};
logger?: Logger | false;
loadSchema?: (uri: string) => Promise<AnySchemaObject>;
removeAdditional?: boolean | "all" | "failing";
useDefaults?: boolean | "empty";
coerceTypes?: boolean | "array";
next?: boolean;
unevaluated?: boolean;
dynamicRef?: boolean;
schemaId?: "id" | "$id";
jtd?: boolean;
meta?: SchemaObject | boolean;
defaultMeta?: string | AnySchemaObject;
validateSchema?: boolean | "log";
addUsedSchema?: boolean;
inlineRefs?: boolean | number;
passContext?: boolean;
loopRequired?: number;
loopEnum?: number;
ownProperties?: boolean;
multipleOfPrecision?: number;
int32range?: boolean;
messages?: boolean;
code?: CodeOptions;
uriResolver?: UriResolver;
}
export interface CodeOptions {
es5?: boolean;
esm?: boolean;
lines?: boolean;
optimize?: boolean | number;
formats?: Code;
source?: boolean;
process?: (code: string, schema?: SchemaEnv) => string;
regExp?: RegExpEngine;
}
interface InstanceCodeOptions extends CodeOptions {
regExp: RegExpEngine;
optimize: number;
}
interface DeprecatedOptions {
/** @deprecated */
ignoreKeywordsWithRef?: boolean;
/** @deprecated */
jsPropertySyntax?: boolean;
/** @deprecated */
unicode?: boolean;
}
type RequiredInstanceOptions = {
[K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp" | "uriResolver"]: NonNullable<Options[K]>;
} & {
code: InstanceCodeOptions;
};
export type InstanceOptions = Options & RequiredInstanceOptions;
export interface Logger {
log(...args: unknown[]): unknown;
warn(...args: unknown[]): unknown;
error(...args: unknown[]): unknown;
}
export default class Ajv {
opts: InstanceOptions;
errors?: ErrorObject[] | null;
logger: Logger;
readonly scope: ValueScope;
readonly schemas: {
[Key in string]?: SchemaEnv;
};
readonly refs: {
[Ref in string]?: SchemaEnv | string;
};
readonly formats: {
[Name in string]?: AddedFormat;
};
readonly RULES: ValidationRules;
readonly _compilations: Set<SchemaEnv>;
private readonly _loading;
private readonly _cache;
private readonly _metaOpts;
static ValidationError: typeof ValidationError;
static MissingRefError: typeof MissingRefError;
constructor(opts?: Options);
_addVocabularies(): void;
_addDefaultMetaSchema(): void;
defaultMeta(): string | AnySchemaObject | undefined;
validate(schema: Schema | string, data: unknown): boolean;
validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise<unknown>;
validate<T>(schema: Schema | JSONSchemaType<T> | string, data: unknown): data is T;
validate<T>(schema: JTDSchemaType<T>, data: unknown): data is T;
validate<N extends never, T extends SomeJTDSchemaType>(schema: T, data: unknown): data is JTDDataType<T>;
validate<T>(schema: AsyncSchema, data: unknown | T): Promise<T>;
validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>;
compile<T = unknown>(schema: Schema | JSONSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
compile<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
compile<N extends never, T extends SomeJTDSchemaType>(schema: T, _meta?: boolean): ValidateFunction<JTDDataType<T>>;
compile<T = unknown>(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction<T>;
compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T>;
compileAsync<T = unknown>(schema: SchemaObject | JSONSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
compileAsync<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
compileAsync<T = unknown>(schema: AsyncSchema, meta?: boolean): Promise<AsyncValidateFunction<T>>;
compileAsync<T = unknown>(schema: AnySchemaObject, meta?: boolean): Promise<AnyValidateFunction<T>>;
addSchema(schema: AnySchema | AnySchema[], // If array is passed, `key` will be ignored
key?: string, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.
_meta?: boolean, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
_validateSchema?: boolean | "log"): Ajv;
addMetaSchema(schema: AnySchemaObject, key?: string, // schema key
_validateSchema?: boolean | "log"): Ajv;
validateSchema(schema: AnySchema, throwOrLogError?: boolean): boolean | Promise<unknown>;
getSchema<T = unknown>(keyRef: string): AnyValidateFunction<T> | undefined;
removeSchema(schemaKeyRef?: AnySchema | string | RegExp): Ajv;
addVocabulary(definitions: Vocabulary): Ajv;
addKeyword(kwdOrDef: string | KeywordDefinition, def?: KeywordDefinition): Ajv;
getKeyword(keyword: string): AddedKeywordDefinition | boolean;
removeKeyword(keyword: string): Ajv;
addFormat(name: string, format: Format): Ajv;
errorsText(errors?: ErrorObject[] | null | undefined, // optional array of validation errors
{ separator, dataVar }?: ErrorsTextOptions): string;
$dataMetaSchema(metaSchema: AnySchemaObject, keywordsJsonPointers: string[]): AnySchemaObject;
private _removeAllSchemas;
_addSchema(schema: AnySchema, meta?: boolean, baseId?: string, validateSchema?: boolean | "log", addSchema?: boolean): SchemaEnv;
private _checkUnique;
private _compileSchemaEnv;
private _compileMetaSchema;
}
export interface ErrorsTextOptions {
separator?: string;
dataVar?: string;
}
|