| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/openskillpaths/node_modules/ajv/lib/types/ |
Upload File : |
import {URIComponent} from "fast-uri"
import type {CodeGen, Code, Name, ScopeValueSets, ValueScopeName} from "../compile/codegen"
import type {SchemaEnv, SchemaCxt, SchemaObjCxt} from "../compile"
import type {JSONType} from "../compile/rules"
import type {KeywordCxt} from "../compile/validate"
import type Ajv from "../core"
interface _SchemaObject {
id?: string
$id?: string
$schema?: string
[x: string]: any // TODO
}
export interface SchemaObject extends _SchemaObject {
id?: string
$id?: string
$schema?: string
$async?: false
[x: string]: any // TODO
}
export interface AsyncSchema extends _SchemaObject {
$async: true
}
export type AnySchemaObject = SchemaObject | AsyncSchema
export type Schema = SchemaObject | boolean
export type AnySchema = Schema | AsyncSchema
export type SchemaMap = {[Key in string]?: AnySchema}
export interface SourceCode {
validateName: ValueScopeName
validateCode: string
scopeValues: ScopeValueSets
evaluated?: Code
}
export interface DataValidationCxt<T extends string | number = string | number> {
instancePath: string
parentData: {[K in T]: any} // object or array
parentDataProperty: T // string or number
rootData: Record<string, any> | any[]
dynamicAnchors: {[Ref in string]?: ValidateFunction}
}
export interface ValidateFunction<T = unknown> {
// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
(this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T
errors?: null | ErrorObject[]
evaluated?: Evaluated
schema: AnySchema
schemaEnv: SchemaEnv
source?: SourceCode
}
export interface JTDParser<T = unknown> {
(json: string): T | undefined
message?: string
position?: number
}
export type EvaluatedProperties = {[K in string]?: true} | true
export type EvaluatedItems = number | true
export interface Evaluated {
// determined at compile time if staticProps/Items is true
props?: EvaluatedProperties
items?: EvaluatedItems
// whether props/items determined at compile time
dynamicProps: boolean
dynamicItems: boolean
}
export interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
(...args: Parameters<ValidateFunction<T>>): Promise<T>
$async: true
}
export type AnyValidateFunction<T = any> = ValidateFunction<T> | AsyncValidateFunction<T>
export interface ErrorObject<K extends string = string, P = Record<string, any>, S = unknown> {
keyword: K
instancePath: string
schemaPath: string
params: P
// Added to validation errors of "propertyNames" keyword schema
propertyName?: string
// Excluded if option `messages` set to false.
message?: string
// These are added with the `verbose` option.
schema?: S
parentSchema?: AnySchemaObject
data?: unknown
}
export type ErrorNoParams<K extends string, S = unknown> = ErrorObject<K, Record<string, never>, S>
interface _KeywordDef {
keyword: string | string[]
type?: JSONType | JSONType[] // data types that keyword applies to
schemaType?: JSONType | JSONType[] // allowed type(s) of keyword value in the schema
allowUndefined?: boolean // used for keywords that can be invoked by other keywords, not being present in the schema
$data?: boolean // keyword supports [$data reference](../../docs/guide/combining-schemas.md#data-reference)
implements?: string[] // other schema keywords that this keyword implements
before?: string // keyword should be executed before this keyword (should be applicable to the same type)
post?: boolean // keyword should be executed after other keywords without post flag
metaSchema?: AnySchemaObject // meta-schema for keyword schema value - it is better to use schemaType where applicable
validateSchema?: AnyValidateFunction // compiled keyword metaSchema - should not be passed
dependencies?: string[] // keywords that must be present in the same schema
error?: KeywordErrorDefinition
$dataError?: KeywordErrorDefinition
}
export interface CodeKeywordDefinition extends _KeywordDef {
code: (cxt: KeywordCxt, ruleType?: string) => void
trackErrors?: boolean
}
export type MacroKeywordFunc = (
schema: any,
parentSchema: AnySchemaObject,
it: SchemaCxt
) => AnySchema
export type CompileKeywordFunc = (
schema: any,
parentSchema: AnySchemaObject,
it: SchemaObjCxt
) => DataValidateFunction
export interface DataValidateFunction {
(...args: Parameters<ValidateFunction>): boolean | Promise<any>
errors?: Partial<ErrorObject>[]
}
export interface SchemaValidateFunction {
(
schema: any,
data: any,
parentSchema?: AnySchemaObject,
dataCxt?: DataValidationCxt
): boolean | Promise<any>
errors?: Partial<ErrorObject>[]
}
export interface FuncKeywordDefinition extends _KeywordDef {
validate?: SchemaValidateFunction | DataValidateFunction
compile?: CompileKeywordFunc
// schema: false makes validate not to expect schema (DataValidateFunction)
schema?: boolean // requires "validate"
modifying?: boolean
async?: boolean
valid?: boolean
errors?: boolean | "full"
}
export interface MacroKeywordDefinition extends FuncKeywordDefinition {
macro: MacroKeywordFunc
}
export type KeywordDefinition =
| CodeKeywordDefinition
| FuncKeywordDefinition
| MacroKeywordDefinition
export type AddedKeywordDefinition = KeywordDefinition & {
type: JSONType[]
schemaType: JSONType[]
}
export interface KeywordErrorDefinition {
message: string | Code | ((cxt: KeywordErrorCxt) => string | Code)
params?: Code | ((cxt: KeywordErrorCxt) => Code)
}
export type Vocabulary = (KeywordDefinition | string)[]
export interface KeywordErrorCxt {
gen: CodeGen
keyword: string
data: Name
$data?: string | false
schema: any // TODO
parentSchema?: AnySchemaObject
schemaCode: Code | number | boolean
schemaValue: Code | number | boolean
schemaType?: JSONType[]
errsCount?: Name
params: KeywordCxtParams
it: SchemaCxt
}
export type KeywordCxtParams = {[P in string]?: Code | string | number}
export type FormatValidator<T extends string | number> = (data: T) => boolean
export type FormatCompare<T extends string | number> = (data1: T, data2: T) => number | undefined
export type AsyncFormatValidator<T extends string | number> = (data: T) => Promise<boolean>
export interface FormatDefinition<T extends string | number> {
type?: T extends string ? "string" | undefined : "number"
validate: FormatValidator<T> | (T extends string ? string | RegExp : never)
async?: false | undefined
compare?: FormatCompare<T>
}
export interface AsyncFormatDefinition<T extends string | number> {
type?: T extends string ? "string" | undefined : "number"
validate: AsyncFormatValidator<T>
async: true
compare?: FormatCompare<T>
}
export type AddedFormat =
| true
| RegExp
| FormatValidator<string>
| FormatDefinition<string>
| FormatDefinition<number>
| AsyncFormatDefinition<string>
| AsyncFormatDefinition<number>
export type Format = AddedFormat | string
export interface RegExpEngine {
(pattern: string, u: string): RegExpLike
code: string
}
export interface RegExpLike {
test: (s: string) => boolean
}
export interface UriResolver {
parse(uri: string): URIComponent
resolve(base: string, path: string): string
serialize(component: URIComponent): string
}