[Typia] Universal Random Generator, which can make everything, just by only one line

import typia from "typia";

const article: IBbsArticle = typia.random<IBbsArticle>();

interface IBbsArticle {
    /**
     * @format uuid
     */
    id: string;
    writer: IBbsArticle.IWriter;
    /**
     * @minItems 1
     * @maxItems 10
     */
    snapshots: IBbsArticle.ISnapshot[];
}
namespace IBbsArticle {
    export interface IWriter {
        /**
         * @pattern ^[a-zA-Z0-9]{3,20}$
         */
        name: string | null;
        /**
         * @format email
         */
        email: string;
    }
    export interface ISnapshot {
        /**
         * @format uuid
         */
        id: string;
        /**
         * @minLength 5
         * @maxLength 100
         */
        title: string;
        body: string;
    }
}

import typia from "typia";
const article = ((generator = typia.random.generator) => {
    const $generator = typia.random.generator;
    const $pick = typia.random.pick;
    const $ro0 = (recursive = false, depth = 0) => ({
        id: (generator.uuid ?? $generator.uuid)(),
        writer: $ro1(recursive, recursive ? 1 + depth : depth),
        snapshots: generator.array(
            () => $ro2(recursive, recursive ? 1 + depth : depth),
            generator.integer(1, 3),
        ),
    });
    const $ro1 = (recursive = false, depth = 0) => ({
        name: $pick([
            () => null,
            () =>
                (generator.pattern ?? $generator.pattern)(
                    /^[a-zA-Z0-9]{3,20}$/,
                ),
        ])(),
        email: (generator.email ?? $generator.email)(),
    });
    const $ro2 = (recursive = false, depth = 0) => ({
        id: (generator.uuid ?? $generator.uuid)(),
        title: generator.string(generator.integer(5, 100)),
        body: generator.string(),
    });
    return $ro0();
})();

export interface TagExample {
    /* -----------------------------------------------------------
        ARRAYS
    ----------------------------------------------------------- */
    /**
     * You can limit array length like below.
     * 
     * @minItems 3
     * @maxItems 10
     * 
     * Also, you can use `@items` tag to fix length.
     * 
     * @items 5
     * 
     * Furthermore, you can use additional tags for each item.
     * 
     * @type uint
     * @format uuid
     */
    array: Array<string|number>;

    /**
     * If two-dimensional array comes, length limit would work for 
     * both 1st and 2nd level arrays. Also using additional tags 
     * for each item (string) would still work.
     * 
     * @minItems 5
     * @maxItems 10
     * @format url
     */
    matrix: string[][];

    /* -----------------------------------------------------------
        NUMBERS
    ----------------------------------------------------------- */
    /**
     * Type of number.
     * 
     * It must be one of integer or unsigned integer.
     * 
     * @type int
     * @type uint
     */
    type: number;

    /**
     * You can limit range of numeric value like below.
     * 
     * @minimum 5
     * @maximum 10
     * 
     * Also, you can use exclusive tags instead
     * 
     * @exclusiveMinimum 4
     * @exclusiveMaximum 11
     */
    range: number;

    /**
     * Step tag requires minimum or exclusiveMinimum tag.
     * 
     * 3, 13, 23, 33, ...
     * 
     * @step 10
     * @exclusiveMinimum 3
     */
    step: number;

    /**
     * Value must be multiple of the given number.
     * 
     * -5, 0, 5, 10, 15, ...
     * 
     * @multipleOf 5
     */
    multipleOf: number;

    /* -----------------------------------------------------------
        STRINGS
    ----------------------------------------------------------- */
    /**
     * You can limit string length like below.
     * 
     * @minLength 3
     * @maxLength 10
     * 
     * Also, you can use `@length` tag to fix length.
     * 
     * @length 7
     */
    length: string;

    /**
     * Mobile number composed by only numbers.
     * 
     * Note that, `typia` does not support flag of regex,
     * because JSON schema definition does not support it either.
     * Therefore, write regex pattern without `/` characters and flag.
     * 
     * @pattern ^0[0-9]{7,16} 
     *     -> RegExp(/[0-9]{7,16}/).test("01012345678")
     */
    mobile: string;

    /**
     * E-mail address.
     * 
     * @format email
     */
    email: string;

    /**
     * UUID value.
     * 
     * @format uuid
     */
    uuid: string;

    /**
     * URL address.
     * 
     * @format url
     */
    url: string;

    /**
     * IPv4 address.
     * 
     * @format ipv4
     */
    ipv4: string;

    /**
     * IPv6 address.
     * 
     * @format ipv6
     */
    ipv6: string;
}

// RUNTIME VALIDATORS
export function is<T>(input: unknown | T): input is T; // returns boolean
export function assert<T>(input: unknown | T): T; // throws TypeGuardError
export function validate<T>(input: unknown | T): IValidation<T>; // detailed

// JSON
export function application<T>(): IJsonApplication; // JSON schema
export function assertParse<T>(input: string): T; // type safe parser
export function assertStringify<T>(input: T): string; // safe and faster
    // +) isParse, validateParse 
    // +) stringify, isStringify, validateStringify

// MISC
export function random<T>(): Primitive<T>; // generate random data
export function clone<T>(input: T): Primitive<T>;
export function prune<T extends object>(input: T): void;
    // +) isClone, assertClone, validateClone
    // +) isPrune, assertPrune, validatePrune