container.ts/lib/validate/Schema.d.ts

Modular application framework

import { ErrorChain } from "../error";
import { Field } from "./Field";
/** Schema error class. */
export declare class SchemaError extends ErrorChain {
    constructor(keys: string, cause?: any);
}
export declare type ISchemaTypes = ISchemaArray | ISchemaMap;
export declare type ISchemaFields = ISchemaTypes | Schema | Field<any>;
/** Schema array type, recursive type. */
export interface ISchemaArray {
    [key: number]: ISchemaFields;
}
/** Schema map type, recursive type. */
export interface ISchemaMap {
    [key: string]: ISchemaFields;
}
/** Schema mask type, recursive type. */
export interface ISchemaMask {
    [key: string]: ISchemaMask | boolean;
}
/** Schema map callback handlers. */
export interface ISchemaMapHandlers {
    isSchemaArray?: (i: any, o: any, array: ISchemaArray, k: number | string, m?: ISchemaMask, kr?: string) => void;
    isSchemaMap?: (i: any, o: any, map: ISchemaMap, k: number | string, m?: ISchemaMask, kr?: string) => void;
    isSchema?: (i: any, o: any, schema: ISchemaConstructor, k: number | string, m?: ISchemaMask, kr?: string) => void;
    isField?: (i: any, o: any, field: Field<any>, k: number | string) => void;
}
/** Schema static interface. */
export interface ISchemaConstructor {
    SCHEMA: ISchemaTypes;
    new (): Schema;
    isSchema(value: any): boolean;
    map(inp: any, out: any, schema: ISchemaTypes, mask?: ISchemaMask, dataKeys?: Array<number | string>, keyRoot?: string, handlers?: ISchemaMapHandlers): void;
    validate<T>(data: any, mask?: ISchemaMask, keyRoot?: string): T;
    format<T>(data: T, mask?: ISchemaMask, keyRoot?: string): any;
}
/** Build schema class from input map. */
export declare function buildSchema(schema?: ISchemaTypes): ISchemaConstructor;
export declare abstract class Schema {
    /** Schema array or map, override in child classes. */
    static readonly SCHEMA: ISchemaTypes;
    /**
     * Returns true if value is a Schema class object.
     * Used to test for child schemas during validation/formatting.
     */
    static isSchema(value: any): boolean;
    /**
     * Helper for iterating over schema fields.
     */
    static map(inp: any, out: any, schema: ISchemaTypes, mask?: ISchemaMask | null, dataKeys?: Array<number | string>, keyRoot?: string, handlers?: ISchemaMapHandlers): void;
    /**
     * Validate input data, transform strings to typed values.
     * All static validation rules are applied, undefined data validation
     * callbacks must provide a default value, null or throw an error.
     * @param data Input data.
     */
    static validate<T>(data: any, mask?: ISchemaMask, keyRoot?: string, schema?: ISchemaTypes): T;
    /**
     * Format input data, transform typed values to object of strings for serialisation.
     * Classes static format rules are applied where data is available.
     * @param data Input data.
     */
    static format<T>(data: T, mask?: ISchemaMask, keyRoot?: string, schema?: ISchemaTypes): any;
    protected static readonly validateMapHandlers: ISchemaMapHandlers;
    protected static readonly formatMapHandlers: ISchemaMapHandlers;
    /** Internal schema map handler. */
    protected static mapHandler(inp: any, out: any, mask: ISchemaMask | null, keyRoot: string, handlers: ISchemaMapHandlers, value: any, key: number | string): void;
}