swagger-typed-express-docs/dist/schemaBuilder.d.ts

Simple express runtime parser and documentation swagger generator with 100% support of Typescript static types

import { DeepWriteable, NiceMerge } from './generics';
import { InferSchemaType, TSchema } from './tsSchema';
export declare const tTransformType: <EncodedTSchema extends TSchema, DecodedTSchema extends TSchema, R, RR>(encodedTSchema: EncodedTSchema, decodedTSchema: DecodedTSchema, syncDecoder: (value: any) => R, syncEncoder?: (value: R) => RR) => {
    type: "transformType";
    encodedTSchema: EncodedTSchema;
    decodedTSchema: DecodedTSchema;
    required: true;
    syncDecoder: (value: any) => R;
    syncEncoder: (value: R) => RR;
};
export declare const T: {
    number: {
        type: "number";
        required: true;
    };
    null_number: {
        type: "number";
        required: false;
    };
    boolean: {
        type: "boolean";
        required: true;
    };
    null_boolean: {
        type: "boolean";
        required: false;
    };
    string: {
        type: "string";
        required: true;
    };
    null_string: {
        type: "string";
        required: false;
    };
    any: {
        type: "any";
        required: true;
    };
    null_any: {
        type: "any";
        required: false;
    };
    oneOf: <T extends readonly Record<any, any>[] | Record<any, any>[]>(options: T) => {
        type: "oneOf";
        options: DeepWriteable<T>;
        required: true;
    };
    null_oneOf: <T_1 extends readonly Record<any, any>[] | Record<any, any>[]>(options: T_1) => {
        type: "oneOf";
        options: DeepWriteable<T_1>;
        required: false;
    };
    enum: <T_2 extends readonly (string | number | boolean)[] | (string | number | boolean)[]>(options: T_2) => {
        type: "enum";
        options: DeepWriteable<T_2>;
        required: true;
    };
    null_enum: <T_3 extends readonly (string | number | boolean)[] | (string | number | boolean)[]>(options: T_3) => {
        type: "enum";
        options: DeepWriteable<T_3>;
        required: false;
    };
    object: <T_4 extends Record<string, TSchema>>(args: T_4) => {
        properties: T_4;
        type: "object";
        required: true;
    };
    null_object: <T_5 extends Record<string, TSchema>>(args: T_5) => {
        properties: T_5;
        type: "object";
        required: false;
    };
    list: <T_6 extends TSchema>(items: T_6) => {
        type: "array";
        items: T_6;
        required: true;
    };
    null_list: <T_7 extends TSchema>(items: T_7) => {
        type: "array";
        items: T_7;
        required: false;
    };
    hashMap: <T_8 extends TSchema>(args: T_8) => {
        type: "hashMap";
        property: T_8;
        required: true;
    };
    null_hashMap: <T_9 extends TSchema>(args: T_9) => {
        type: "hashMap";
        property: T_9;
        required: false;
    };
    transformType: <EncodedTSchema extends TSchema, DecodedTSchema extends TSchema, R, RR>(encodedTSchema: EncodedTSchema, decodedTSchema: DecodedTSchema, syncDecoder: (value: any) => R, syncEncoder?: (value: R) => RR) => {
        type: "transformType";
        encodedTSchema: EncodedTSchema;
        decodedTSchema: DecodedTSchema;
        required: true;
        syncDecoder: (value: any) => R;
        syncEncoder: (value: R) => RR;
    };
    addValidator: <T_10 extends TSchema>(schema: T_10, validator: (val: InferSchemaType<T_10>) => void) => T_10 & {
        validator: (val: InferSchemaType<T_10>) => void;
    };
    deepNullable: (schema: TSchema) => any;
    nonNullable: <T_11 extends {
        required: any;
    }>(a: T_11) => Omit<T_11, "required"> & {
        required: true;
    } extends infer T_12 ? { [K in keyof T_12]: (Omit<T_11, "required"> & {
        required: true;
    })[K]; } : never;
    nullable: <T_13 extends {
        required: any;
    }>(a: T_13) => Omit<T_13, "required"> & {
        required: false;
    } extends infer T_14 ? { [K_1 in keyof T_14]: (Omit<T_13, "required"> & {
        required: false;
    })[K_1]; } : never;
    nullableTransform: <T_15 extends {
        encodedTSchema: {
            required: boolean;
        };
        decodedTSchema: {
            required: boolean;
        };
    }>(a: T_15) => Omit<T_15, "encodedTSchema" | "decodedTSchema"> & {
        encodedTSchema: Omit<T_15["encodedTSchema"], "required"> & {
            required: false;
        } extends infer T_17 ? { [K_3 in keyof T_17]: (Omit<T_15["encodedTSchema"], "required"> & {
            required: false;
        })[K_3]; } : never;
        decodedTSchema: Omit<T_15["decodedTSchema"], "required"> & {
            required: false;
        } extends infer T_18 ? { [K_4 in keyof T_18]: (Omit<T_15["decodedTSchema"], "required"> & {
            required: false;
        })[K_4]; } : never;
    } extends infer T_16 ? { [K_2 in keyof T_16]: (Omit<T_15, "encodedTSchema" | "decodedTSchema"> & {
        encodedTSchema: Omit<T_15["encodedTSchema"], "required"> & {
            required: false;
        } extends infer T_17 ? { [K_3 in keyof T_17]: (Omit<T_15["encodedTSchema"], "required"> & {
            required: false;
        })[K_3]; } : never;
        decodedTSchema: Omit<T_15["decodedTSchema"], "required"> & {
            required: false;
        } extends infer T_18 ? { [K_4 in keyof T_18]: (Omit<T_15["decodedTSchema"], "required"> & {
            required: false;
        })[K_4]; } : never;
    })[K_2]; } : never;
    lazy: (name: string, tSchema: () => any) => {
        type: "lazy";
        name: string;
        required: boolean;
        getSchema: () => any;
    };
};