@backland/schema/lib/Tokenizer/SimpleTokens.d.ts

TypeScript schema declaration and validation library with static type inference

import { Merge } from '@backland/utils';
import { Infer } from '../Infer';
import { DescribeField } from '../fields/Infer';
import { FieldAsString } from '../fields/_parseFields';
import { SplitTokens } from './SplitTokens';
export declare function $<T extends _SimpleTokens[]>(...field: T): Parse<T>;
declare const tt: {
    name: {
        name?: string | undefined;
        def: undefined;
        description?: string | undefined;
        hidden?: boolean | undefined;
        list: false;
        optional: false;
        type: "string";
        example?: import("..").FieldExample | undefined;
        $sealed: {
            literal: typeof import("../fields/Infer").$sealed;
            optional: false;
            list: false;
            description?: string | undefined;
            example?: import("..").FieldExample | undefined;
            hidden?: boolean | undefined;
            name?: string | undefined;
        };
    };
    age: {
        name?: string | undefined;
        def: undefined;
        description?: string | undefined;
        hidden?: boolean | undefined;
        list: true;
        optional: true;
        type: "int";
        example?: import("..").FieldExample | undefined;
        $sealed: {
            literal: typeof import("../fields/Infer").$sealed;
            optional: false;
            list: false;
            description?: string | undefined;
            example?: import("..").FieldExample | undefined;
            hidden?: boolean | undefined;
            name?: string | undefined;
        };
    };
};
export type Funny = Infer<typeof tt>;
export type _SimpleTokens = `${string}${':' | ': ' | ' '}${FieldAsString}${';' | ''}`;
export type Parse<T extends string[]> = _Parse<SplitTokens<T>>;
export type _Parse<T extends string[]> = T extends [] ? {} : T extends [infer K, infer V, ...infer Rest] ? K extends `${infer KV}:` ? V extends string ? Rest extends [] ? ParsePair<KV, V> : Rest extends string[] ? Merge<ParsePair<KV, V>, _Parse<Rest>> extends infer R ? {
    [K in keyof R]: R[K];
} & {} : never : {} : 1 : 2 : 3;
type ParsePair<K, V> = K extends unknown ? K extends string ? V extends unknown ? V extends FieldAsString ? {
    [L in K]: DescribeField<V>;
} : never : never : never : never;
export {};