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

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

export { jsValueToSchema, tSchemaToJSValue } from './jsValueToSchema';
export { InferSchemaType, TSchema } from './tsSchema';
export { convertSchemaToYupValidationObject as _convertSchemaToYupValidationObject, getTSchemaValidator, normalizeYupError, } from './runtimeSchemaValidation';
export { apiDoc, getApiDocInstance, getMock_apiDocInstance, initApiDocs, mock_apiDoc, } from './typedExpressDocs';
export { tSchemaToTypescript } from './tSchemaToTypescript';
export { codegenSchemaToJSCode } from './codegen';
export { tUtils } from './tUtils';
export declare const T: {
    cast: {
        date: {
            type: "transformType";
            encodedTSchema: {
                type: "string";
                required: true;
            };
            decodedTSchema: {
                type: "any";
                required: true;
            };
            syncDecoder: (value: any) => Date;
            syncEncoder: (value: Date) => string;
            required: true;
        };
        null_date: {
            type: "transformType";
            encodedTSchema: {
                type: "string";
                required: false;
            };
            decodedTSchema: {
                type: "any";
                required: false;
            };
            syncDecoder: (value: any) => Date;
            syncEncoder: (value: Date) => string;
            required: false;
        };
        number: {
            type: "transformType";
            encodedTSchema: {
                type: "string";
                required: true;
            };
            decodedTSchema: {
                type: "number";
                required: true;
            };
            syncDecoder: (value: any) => number;
            syncEncoder: (value: number) => string;
            required: true;
        };
        null_number: {
            type: "transformType";
            encodedTSchema: {
                type: "string";
                required: false;
            };
            decodedTSchema: {
                type: "number";
                required: false;
            };
            syncDecoder: (value: any) => number;
            syncEncoder: (value: number) => string;
            required: false;
        };
        boolean: {
            type: "transformType";
            encodedTSchema: {
                type: "enum";
                options: ["true", "false"];
                required: true;
            };
            decodedTSchema: {
                type: "boolean";
                required: true;
            };
            syncDecoder: (value: any) => boolean;
            syncEncoder: (value: boolean) => "true" | "false";
            required: true;
        };
        null_boolean: {
            type: "transformType";
            encodedTSchema: {
                type: "enum";
                options: ["true", "false"];
                required: false;
            };
            decodedTSchema: {
                type: "boolean";
                required: false;
            };
            syncDecoder: (value: any) => boolean;
            syncEncoder: (value: boolean) => "true" | "false";
            required: false;
        };
        isoToJSDate: {
            type: "transformType";
            encodedTSchema: {
                type: "enum";
                options: ["true", "false"];
                required: true;
            };
            decodedTSchema: {
                type: "boolean";
                required: true;
            };
            syncDecoder: (value: any) => boolean;
            syncEncoder: (value: boolean) => "true" | "false";
            required: true;
        };
        null_isoToJSDate: {
            type: "transformType";
            encodedTSchema: {
                type: "enum";
                options: ["true", "false"];
                required: false;
            };
            decodedTSchema: {
                type: "boolean";
                required: false;
            };
            syncDecoder: (value: any) => boolean;
            syncEncoder: (value: boolean) => "true" | "false";
            required: false;
        };
    };
    extra: {
        minMaxNumber: (min: number, max: number) => {
            type: "number";
            required: true;
        } & {
            validator: (val: number) => void;
        };
        null_minMaxNum: (min: number, max: number) => {
            type: "number";
            validator: (val: number) => void;
            required: false;
        };
        ISOString: {
            type: "string";
            required: true;
        } & {
            validator: (val: string) => void;
        };
        null_ISOString: {
            type: "string";
            validator: (val: string) => void;
            required: false;
        };
        minMaxString: (min: number, max: number) => {
            type: "string";
            required: true;
        } & {
            validator: (val: string) => void;
        };
        null_minMaxString: (min: number, max: number) => {
            type: "string";
            validator: (val: string) => void;
            required: false;
        };
        toListIfNot: <T extends import("./tsSchema").TSchema>(tSchema: T) => {
            type: "transformType";
            encodedTSchema: {
                type: "oneOf";
                options: [import("./generics").DeepWriteable<T>, import("./generics").DeepWriteable<{
                    type: "array";
                    items: T;
                    required: true;
                }>];
                required: true;
            };
            decodedTSchema: {
                type: "array";
                items: T;
                required: true;
            };
            required: true;
            syncDecoder: (value: any) => any[];
            syncEncoder: (value: any[]) => any[];
        };
        null_toListIfNot: <T_1 extends import("./tsSchema").TSchema>(arg: T_1) => {
            type: "transformType";
            encodedTSchema: {
                type: "oneOf";
                options: [import("./generics").DeepWriteable<T_1>, import("./generics").DeepWriteable<{
                    type: "array";
                    items: T_1;
                    required: true;
                }>];
                required: true;
            };
            decodedTSchema: {
                type: "array";
                items: T_1;
                required: true;
            };
            syncDecoder: (value: any) => any[];
            syncEncoder: (value: any[]) => any[];
            required: false;
        };
    };
    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_2 extends readonly Record<any, any>[] | Record<any, any>[]>(options: T_2) => {
        type: "oneOf";
        options: import("./generics").DeepWriteable<T_2>;
        required: true;
    };
    null_oneOf: <T_3 extends readonly Record<any, any>[] | Record<any, any>[]>(options: T_3) => {
        type: "oneOf";
        options: import("./generics").DeepWriteable<T_3>;
        required: false;
    };
    enum: <T_4 extends readonly (string | number | boolean)[] | (string | number | boolean)[]>(options: T_4) => {
        type: "enum";
        options: import("./generics").DeepWriteable<T_4>;
        required: true;
    };
    null_enum: <T_5 extends readonly (string | number | boolean)[] | (string | number | boolean)[]>(options: T_5) => {
        type: "enum";
        options: import("./generics").DeepWriteable<T_5>;
        required: false;
    };
    object: <T_6 extends Record<string, import("./tsSchema").TSchema>>(args: T_6) => {
        properties: T_6;
        type: "object";
        required: true;
    };
    null_object: <T_7 extends Record<string, import("./tsSchema").TSchema>>(args: T_7) => {
        properties: T_7;
        type: "object";
        required: false;
    };
    list: <T_8 extends import("./tsSchema").TSchema>(items: T_8) => {
        type: "array";
        items: T_8;
        required: true;
    };
    null_list: <T_9 extends import("./tsSchema").TSchema>(items: T_9) => {
        type: "array";
        items: T_9;
        required: false;
    };
    hashMap: <T_10 extends import("./tsSchema").TSchema>(args: T_10) => {
        type: "hashMap";
        property: T_10;
        required: true;
    };
    null_hashMap: <T_11 extends import("./tsSchema").TSchema>(args: T_11) => {
        type: "hashMap";
        property: T_11;
        required: false;
    };
    transformType: <EncodedTSchema extends import("./tsSchema").TSchema, DecodedTSchema extends import("./tsSchema").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_12 extends import("./tsSchema").TSchema>(schema: T_12, validator: (val: import("./tsSchema").InferSchemaType<T_12>) => void) => T_12 & {
        validator: (val: import("./tsSchema").InferSchemaType<T_12>) => void;
    };
    deepNullable: (schema: import("./tsSchema").TSchema) => any;
    nonNullable: <T_13 extends {
        required: any;
    }>(a: T_13) => Omit<T_13, "required"> & {
        required: true;
    } extends infer T_14 ? { [K in keyof T_14]: (Omit<T_13, "required"> & {
        required: true;
    })[K]; } : never;
    nullable: <T_15 extends {
        required: any;
    }>(a: T_15) => Omit<T_15, "required"> & {
        required: false;
    } extends infer T_16 ? { [K_1 in keyof T_16]: (Omit<T_15, "required"> & {
        required: false;
    })[K_1]; } : never;
    nullableTransform: <T_17 extends {
        encodedTSchema: {
            required: boolean;
        };
        decodedTSchema: {
            required: boolean;
        };
    }>(a: T_17) => Omit<T_17, "encodedTSchema" | "decodedTSchema"> & {
        encodedTSchema: Omit<T_17["encodedTSchema"], "required"> & {
            required: false;
        } extends infer T_21 ? { [K_3 in keyof T_21]: (Omit<T_17["encodedTSchema"], "required"> & {
            required: false;
        })[K_3]; } : never;
        decodedTSchema: Omit<T_17["decodedTSchema"], "required"> & {
            required: false;
        } extends infer T_22 ? { [K_4 in keyof T_22]: (Omit<T_17["decodedTSchema"], "required"> & {
            required: false;
        })[K_4]; } : never;
    } extends infer T_18 ? { [K_2 in keyof T_18]: (Omit<T_17, "encodedTSchema" | "decodedTSchema"> & {
        encodedTSchema: Omit<T_17["encodedTSchema"], "required"> & {
            required: false;
        } extends infer T_19 ? { [K_3 in keyof T_19]: (Omit<T_17["encodedTSchema"], "required"> & {
            required: false;
        })[K_3]; } : never;
        decodedTSchema: Omit<T_17["decodedTSchema"], "required"> & {
            required: false;
        } extends infer T_20 ? { [K_4 in keyof T_20]: (Omit<T_17["decodedTSchema"], "required"> & {
            required: false;
        })[K_4]; } : never;
    })[K_2]; } : never;
    lazy: (name: string, tSchema: () => any) => {
        type: "lazy";
        name: string;
        required: boolean;
        getSchema: () => any;
    };
};