Core Schema Validation

/**
 * Creates a new Ajv validator instance
 * @param options - Configuration options for the validator
 */
constructor(options?: Options);

interface Options extends CurrentOptions, DeprecatedOptions {}

interface CurrentOptions {
  // Strict mode options
  strict?: boolean | "log";
  strictSchema?: boolean | "log"; 
  strictNumbers?: boolean | "log";
  strictTypes?: boolean | "log";
  strictTuples?: boolean | "log";
  strictRequired?: boolean | "log";
  allowMatchingProperties?: boolean;
  allowUnionTypes?: boolean;
  validateFormats?: boolean;
  
  // Validation and reporting options
  $data?: boolean;
  allErrors?: boolean;
  verbose?: boolean;
  $comment?: boolean | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => void);
  formats?: {[Name in string]?: Format};
  loadSchema?: (uri: string) => Promise<AnySchemaObject>;
  
  // Options to modify validated data
  useDefaults?: boolean | "empty";
  coerceTypes?: boolean | "array";
  removeAdditional?: boolean | "all" | "failing";
  
  // Advanced options
  next?: boolean;
  unevaluated?: boolean;
  dynamicRef?: boolean;
  schemaId?: "id" | "$id";
  addUsedSchema?: boolean;
  validateSchema?: boolean | "log";
  meta?: boolean | SchemaObject;
  defaultMeta?: string | SchemaObject;
  inlineRefs?: boolean | number;
  passContext?: boolean;
  loopRequired?: number;
  ownProperties?: boolean;
  multipleOfPrecision?: number;
  discriminator?: boolean;
  unicodeRegExp?: boolean;
  int32range?: boolean;
}

import Ajv from "ajv";

// Basic validator
const ajv = new Ajv();

// Strict mode enabled
const strictAjv = new Ajv({ strict: true });

// All errors collection
const verboseAjv = new Ajv({ allErrors: true, verbose: true });

// With data coercion
const coercingAjv = new Ajv({ coerceTypes: true });

/**
 * Validates data against a schema
 * @param schema - JSON Schema or schema reference
 * @param data - Data to validate
 * @returns true if valid, false otherwise. Sets errors property on instance
 */
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<T>(schema: AsyncSchema, data: unknown): Promise<T>;
validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>;

import Ajv from "ajv";

const ajv = new Ajv();

// Inline schema validation
const schema = {
  type: "object",
  properties: {
    name: { type: "string" },
    age: { type: "number", minimum: 0 }
  },
  required: ["name"]
};

const data = { name: "John", age: 30 };
const valid = ajv.validate(schema, data);

if (!valid) {
  console.log("Validation errors:", ajv.errors);
}

// Pre-compiled validation function
const validateUser = ajv.compile(schema);
const isValid = ajv.validate(validateUser, data);

/**
 * Compiles a schema into a validation function
 * @param schema - JSON Schema to compile
 * @param meta - Optional flag for meta-schema compilation
 * @returns Compiled validation function with type guards
 */
compile<T = unknown>(schema: Schema | JSONSchemaType<T>, meta?: boolean): ValidateFunction<T>;
compile<T = unknown>(schema: JTDSchemaType<T>, meta?: boolean): ValidateFunction<T>;
compile<T = unknown>(schema: AsyncSchema, meta?: boolean): AsyncValidateFunction<T>;
compile<T = unknown>(schema: AnySchema, meta?: boolean): AnyValidateFunction<T>;

interface ValidateFunction<T = unknown> {
  (data: unknown): data is T;
  errors?: ErrorObject[] | null;
  evaluated?: Evaluated;
  schema: AnySchema;
  schemaEnv: SchemaEnv;
  source?: SourceCode;
}

import Ajv from "ajv";

const ajv = new Ajv();

// Compile schema once
const schema = {
  type: "object",
  properties: {
    email: { type: "string", format: "email" },
    age: { type: "integer", minimum: 18 }
  },
  required: ["email", "age"]
};

const validate = ajv.compile(schema);

// Reuse compiled function multiple times
const users = [
  { email: "user1@example.com", age: 25 },
  { email: "user2@example.com", age: 30 },
  { email: "invalid-email", age: 16 }
];

users.forEach((user, index) => {
  const valid = validate(user);
  console.log(`User ${index + 1} valid:`, valid);
  if (!valid) {
    console.log("Errors:", validate.errors);
  }
});

/**
 * Compiles schema with async validation support
 * @param schema - JSON Schema (may contain $async: true or remote $refs)
 * @param meta - Optional flag for meta-schema compilation
 * @returns Promise resolving to async validation function
 */
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>>;

interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
  (data: unknown): Promise<T>;
  $async: true;
}

interface AsyncSchema extends SchemaObject {
  $async: true;
}

import Ajv from "ajv";

const ajv = new Ajv({ loadSchema: loadRemoteSchema });

// Schema with remote references
const schema = {
  $async: true,
  type: "object",
  properties: {
    user: { $ref: "https://example.com/user-schema.json" },
    metadata: { type: "object" }
  }
};

async function validateAsyncData() {
  try {
    const validate = await ajv.compileAsync(schema);
    
    const data = {
      user: { name: "Alice", email: "alice@example.com" },
      metadata: { source: "api" }
    };
    
    const result = await validate(data);
    console.log("Validated data:", result);
  } catch (error) {
    console.log("Validation failed:", error);
  }
}

// Custom remote schema loader
async function loadRemoteSchema(uri: string): Promise<SchemaObject> {
  const response = await fetch(uri);
  return response.json();
}

/**
 * Formats validation errors as human-readable text
 * @param errors - Array of error objects (defaults to ajv.errors)
 * @param options - Formatting options
 * @returns Formatted error string
 */
errorsText(errors?: ErrorObject[] | null, options?: ErrorsTextOptions): string;

interface ErrorsTextOptions {
  separator?: string;
  dataVar?: string;
}

import Ajv from "ajv";

const ajv = new Ajv({ allErrors: true });

const schema = {
  type: "object",
  properties: {
    name: { type: "string", minLength: 2 },
    email: { type: "string", format: "email" },
    age: { type: "number", minimum: 0 }
  },
  required: ["name", "email"]
};

const data = { name: "A", age: -5 };
const valid = ajv.validate(schema, data);

if (!valid) {
  // Default formatting
  console.log(ajv.errorsText());
  
  // Custom formatting
  console.log(ajv.errorsText(ajv.errors, {
    separator: "\n",
    dataVar: "user"
  }));
}

interface ValidateFunction<T = unknown> {
  /** The validation function that returns type guard */
  (data: unknown): data is T;
  
  /** Array of validation errors (null if valid) */
  errors?: ErrorObject[] | null;
  
  /** The original schema used for compilation */
  schema: AnySchema;
  
  /** Schema compilation environment with metadata */
  schemaEnv: SchemaEnv;
  
  /** Generated source code (if enabled in options) */
  sourcecode?: SourceCode;
}