indicative-parser/build/src/Contracts/index.d.ts

Schema parser for Indicative

/**
 * Parsed rule is created by parsing a single rule defination
 * like `required` or `min:4`
 */
export declare type ParsedRule = {
    name: string;
    args: any[];
};
/**
 * Array node defines the fields which uses one of the following
 * array expressions.
 *
 * 1. users.*.username
 * 2. users.*
 * 3. users.0.username
 * 4. users.0
 */
export declare type SchemaNodeArray = {
    type: 'array';
    rules: ParsedRule[];
    each: {
        [index: string]: {
            rules: ParsedRule[];
            children: ParsedSchema;
        };
    };
};
/**
 * Object node defines the fields which uses one of the following
 * object expressions.
 *
 * 1. user.username
 */
export declare type SchemaNodeObject = {
    type: 'object';
    rules: ParsedRule[];
    children: ParsedSchema;
};
/**
 * Literal are leaf nodes inside the tree. A literal can exist
 * on an array or object or direct leafs of a flat tree
 */
export declare type SchemaNodeLiteral = {
    type: 'literal';
    rules: ParsedRule[];
};
/**
 * Shape of the schema defined by the end user. In the later version
 * we may drop the `string` based rules
 */
export declare type Schema = {
    [field: string]: string | ParsedRule[];
};
/**
 * The shape of schema after parser parses it
 */
export declare type ParsedSchema = {
    [field: string]: SchemaNodeArray | SchemaNodeLiteral | SchemaNodeObject;
};
/**
 * Shape of a single validation message. The functions are evaluated at runtime
 */
export declare type Message = string | ((field: string, validation: string, args: any[]) => string);
/**
 * ------------------------
 * Shape of messages
 * ------------------------
 */
/**
 * Shape of user defined messages schema
 */
export declare type Messages = {
    [field: string]: Message;
};
/**
 * Shape of parsed messages for a given node
 */
export declare type ParsedRulesMessages = {
    [rule: string]: Message;
};
/**
 * Parsed messages tree
 */
export declare type ParsedFieldsMessages = {
    [field: string]: ParsedRulesMessages;
};
/**
 * Final tree for messages. The `rules` object has flat list of messages
 * for a given rule. However, `fields` are scoped inside a field name.
 */
export declare type ParsedMessages = {
    fields: ParsedFieldsMessages;
    rules: ParsedRulesMessages;
};