@backland/schema/lib/fields/FieldType.d.ts

TypeScript schema declaration and validation library with static type inference

import { FieldParserOptionsObject, FieldTypeParser } from '../applyValidator';
import { $inferableKey } from './Infer';
import { FieldDefinitions, FieldTypeName, ListDefinitionObject, ListDefinitionTruthy } from './_fieldDefinitions';
import { AllFinalFieldDefinitions, FinalFieldDefinitionStrict } from './_parseFields';
export * from '../applyValidator';
export type FieldTypeOptions = ListDefinitionObject & {
    [K: string]: unknown;
};
export type FieldComposer<Schema = Record<string, any>, T = any> = {
    compose: (schema: Schema) => T;
    def: FinalFieldDefinitionStrict;
    validate(input: any, parent: Schema): T;
};
export declare const FieldsTypeCache: Map<string, {
    fieldType: TAnyFieldType;
    defKeys: string[] | undefined;
}>;
export declare abstract class FieldType<Type, TypeName extends FieldTypeName, Def extends FieldDefinitions[TypeName], List extends 1 | 0 = 0, Optional extends 1 | 0 = 0, DefaultValue extends unknown | undefined = undefined, Options extends FieldTypeOptions = {}> {
    readonly typeName: TypeName;
    type: TypeName;
    readonly def: Def;
    [$inferableKey]: ([List] extends [1] ? Type[] : Type) extends infer R ? [Optional] extends [1] ? R | undefined : R : never;
    composer: FieldComposer<Record<string, any>, Type> | undefined;
    get definition(): AllFinalFieldDefinitions[TypeName];
    id?: string;
    name?: string;
    options: Options;
    protected constructor(config: {
        def: Def;
        id?: string;
        name: TypeName;
        options?: Options;
    });
    validate(input: any): input is Type;
    is(input: any): input is Type;
    optional: [Optional] extends [1] ? true : false;
    list: [List] extends [1] ? true : false;
    defaultValue: DefaultValue;
    description?: string;
    hidden?: boolean;
    describe: (description: string) => this;
    describeField: () => {
        def: Def;
        defaultValue: DefaultValue;
        description: string | undefined;
        hidden: boolean;
        list: [List] extends [1] ? true : false;
        optional: [Optional] extends [1] ? true : false;
        type: Type;
    };
    toOptional(): FieldType<Type, TypeName, Def, List, 1, DefaultValue, Options>;
    toRequired(): FieldType<Type, TypeName, Def, List, 0, DefaultValue, Options>;
    toList(options?: ListDefinitionTruthy): FieldType<Type, TypeName, Def, 1, Optional, DefaultValue, Options>;
    setDefaultValue<T extends any>(value: T): FieldType<Type, TypeName, Def, List, Optional, T, Options>;
    applyParser: <Type_1>(parser: {
        parse(input: any, _options: FieldParserOptionsObject): Type_1;
        preParse?(input: any): Type_1;
    }) => FieldTypeParser<Type_1>;
    get asFinalFieldDef(): AllFinalFieldDefinitions[TypeName];
    abstract parse: FieldTypeParser<Type>;
    readonly __isFieldType = true;
    static create(..._args: any[]): TAnyFieldType;
    clone: () => FieldType<Type, TypeName, Def, List, Optional, DefaultValue, Options>;
}
export declare function isFieldInstance(t: any): t is TAnyFieldType;
export type AllFieldTypes = {
    [K in keyof FieldDefinitions]: FieldType<unknown, K, FieldDefinitions[K], 0, 0>;
};
export type TAnyFieldType = AllFieldTypes[keyof AllFieldTypes];