@traversable/schema
    Preparing search index...

    Variable SeedGeneratorConst

    SeedGenerator: <
        Options extends
            GeneratorOptions<
                {
                    any: [10];
                    array: [1000, unknown, Bounds_array];
                    bigint: [150, Bounds_bigint];
                    blob: [27];
                    boolean: [15];
                    custom: [9500, unknown];
                    date: [20];
                    enum: [500, any];
                    file: [25];
                    intersect: [
                        6000,
                        [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                    ];
                    lazy: [10500, (...args: []) => unknown];
                    literal: [550, string | number | boolean];
                    loose_object: [7600, [string, unknown][]];
                    loose_tuple: [8100, unknown[]];
                    map: [6500, [unknown, unknown]];
                    nan: [30];
                    never: [35];
                    non_nullable: [2100, unknown];
                    non_nullish: [2300, unknown];
                    non_optional: [1500, unknown];
                    null: [40];
                    nullable: [2000, unknown];
                    nullish: [2200, unknown];
                    number: [200, Bounds_number];
                    object: [7500, [string, unknown][]];
                    object_with_rest: [7800, [string, unknown][], unknown];
                    optional: [2500, unknown];
                    promise: unknown;
                    record: [7000, unknown];
                    set: [3500, unknown];
                    strict_object: [7700, [string, unknown][]];
                    strict_tuple: [8200, unknown[]];
                    string: [250, Bounds_string];
                    symbol: [45];
                    tuple: [8000, unknown[]];
                    tuple_with_rest: [8300, unknown[], unknown];
                    undefined: [50];
                    undefinedable: [2700, unknown];
                    union: [8500, unknown[]];
                    unknown: [55];
                    variant: [8600, [string, [string, unknown][]][], string];
                    void: [60];
                },
            >,
    >(
        options?: Options,
        overrides?: Partial<
            Gen.Base<
                {
                    any: [10];
                    array: [1000, unknown, Bounds_array];
                    bigint: [150, Bounds_bigint];
                    blob: [27];
                    boolean: [15];
                    custom: [9500, unknown];
                    date: [20];
                    enum: [500, any];
                    file: [25];
                    intersect: [
                        6000,
                        [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                    ];
                    lazy: [10500, (...args: []) => unknown];
                    literal: [550, string | number | boolean];
                    loose_object: [7600, [string, unknown][]];
                    loose_tuple: [8100, unknown[]];
                    map: [6500, [unknown, unknown]];
                    nan: [30];
                    never: [35];
                    non_nullable: [2100, unknown];
                    non_nullish: [2300, unknown];
                    non_optional: [1500, unknown];
                    null: [40];
                    nullable: [2000, unknown];
                    nullish: [2200, unknown];
                    number: [200, Bounds_number];
                    object: [7500, [string, unknown][]];
                    object_with_rest: [7800, [string, unknown][], unknown];
                    optional: [2500, unknown];
                    promise: unknown;
                    record: [7000, unknown];
                    set: [3500, unknown];
                    strict_object: [7700, [string, unknown][]];
                    strict_tuple: [8200, unknown[]];
                    string: [250, Bounds_string];
                    symbol: [45];
                    tuple: [8000, unknown[]];
                    tuple_with_rest: [8300, unknown[], unknown];
                    undefined: [50];
                    undefinedable: [2700, unknown];
                    union: [8500, unknown[]];
                    unknown: [55];
                    variant: [8600, [string, [string, unknown][]][], string];
                    void: [60];
                },
                byTypeName,
            >,
        >,
    ) => Gen.Builder<
        (
            [
                Options["root"] extends | "string"
                | "number"
                | "bigint"
                | "boolean"
                | "symbol"
                | "undefined"
                | "object"
                | "map"
                | "any"
                | "blob"
                | "custom"
                | "date"
                | "file"
                | "never"
                | "null"
                | "promise"
                | "unknown"
                | "void"
                | "enum"
                | "literal"
                | "lazy"
                | "array"
                | "nullable"
                | "nullish"
                | "optional"
                | "set"
                | "undefinedable"
                | "tuple"
                | "union"
                | "variant"
                | "intersect"
                | "record"
                | "nan"
                | "non_nullable"
                | "non_nullish"
                | "non_optional"
                | "strict_tuple"
                | "loose_tuple"
                | "strict_object"
                | "loose_object"
                | "tuple_with_rest"
                | "object_with_rest"
                    ? {
                        any: [10];
                        array: [1000, unknown, Bounds_array];
                        bigint: [150, Bounds_bigint];
                        blob: [27];
                        boolean: [15];
                        custom: [9500, unknown];
                        date: [20];
                        enum: [500, any];
                        file: [25];
                        intersect: [6000, [[(...), (...)], [(...), (...)]]];
                        lazy: [10500, (...args: []) => unknown];
                        literal: [550, string | number | boolean];
                        loose_object: [7600, [(...), (...)][]];
                        loose_tuple: [8100, unknown[]];
                        map: [6500, [unknown, unknown]];
                        nan: [30];
                        never: [35];
                        non_nullable: [2100, unknown];
                        non_nullish: [2300, unknown];
                        non_optional: [1500, unknown];
                        null: [40];
                        nullable: [2000, unknown];
                        nullish: [2200, unknown];
                        number: [200, Bounds_number];
                        object: [7500, [(...), (...)][]];
                        object_with_rest: [7800, [(...), (...)][], unknown];
                        optional: [2500, unknown];
                        promise: unknown;
                        record: [7000, unknown];
                        set: [3500, unknown];
                        strict_object: [7700, [(...), (...)][]];
                        strict_tuple: [8200, unknown[]];
                        string: [250, Bounds_string];
                        symbol: [45];
                        tuple: [8000, unknown[]];
                        tuple_with_rest: [8300, unknown[], unknown];
                        undefined: [50];
                        undefinedable: [2700, unknown];
                        union: [8500, unknown[]];
                        unknown: [55];
                        variant: [8600, [(...), (...)][], string];
                        void: [60];
                    }[any[any]]
                    : never,
            ] extends [never]
                ? unknown
                : {
                    root: Arbitrary<
                        Options["root"] extends | "string"
                        | "number"
                        | "bigint"
                        | "boolean"
                        | "symbol"
                        | "undefined"
                        | "object"
                        | "map"
                        | "any"
                        | "blob"
                        | "custom"
                        | "date"
                        | "file"
                        | "never"
                        | "null"
                        | "promise"
                        | "unknown"
                        | "void"
                        | "enum"
                        | "literal"
                        | "lazy"
                        | "array"
                        | "nullable"
                        | "nullish"
                        | "optional"
                        | "set"
                        | "undefinedable"
                        | "tuple"
                        | "union"
                        | "variant"
                        | "intersect"
                        | "record"
                        | "nan"
                        | "non_nullable"
                        | "non_nullish"
                        | "non_optional"
                        | "strict_tuple"
                        | "loose_tuple"
                        | "strict_object"
                        | "loose_object"
                        | "tuple_with_rest"
                        | "object_with_rest"
                            ? {
                                any: [10];
                                array: [1000, unknown, Bounds_array];
                                bigint: [150, Bounds_bigint];
                                blob: [27];
                                boolean: [15];
                                custom: [9500, unknown];
                                date: [20];
                                enum: [500, any];
                                file: [25];
                                intersect: [6000, [(...), (...)]];
                                lazy: [10500, (...args: ...) => ...];
                                literal: [550, (...) | (...) | (...) | (...)];
                                loose_object: [7600, (...)[]];
                                loose_tuple: [8100, (...)[]];
                                map: [6500, [(...), (...)]];
                                nan: [30];
                                never: [35];
                                non_nullable: [2100, unknown];
                                non_nullish: [2300, unknown];
                                non_optional: [1500, unknown];
                                null: [40];
                                nullable: [2000, unknown];
                                nullish: [2200, unknown];
                                number: [200, Bounds_number];
                                object: [7500, (...)[]];
                                object_with_rest: [7800, (...)[], unknown];
                                optional: [2500, unknown];
                                promise: unknown;
                                record: [7000, unknown];
                                set: [3500, unknown];
                                strict_object: [7700, (...)[]];
                                strict_tuple: [8200, (...)[]];
                                string: [250, Bounds_string];
                                symbol: [45];
                                tuple: [8000, (...)[]];
                                tuple_with_rest: [8300, (...)[], unknown];
                                undefined: [50];
                                undefinedable: [2700, unknown];
                                union: [8500, (...)[]];
                                unknown: [55];
                                variant: [8600, (...)[], string];
                                void: [60];
                            }[any[any]]
                            : never,
                    >;
                }
        ) & {
            [K in | "string"
            | "number"
            | "bigint"
            | "boolean"
            | "symbol"
            | "undefined"
            | "object"
            | "map"
            | "any"
            | "blob"
            | "custom"
            | "date"
            | "file"
            | "never"
            | "null"
            | "promise"
            | "unknown"
            | "void"
            | "enum"
            | "literal"
            | "lazy"
            | "array"
            | "nullable"
            | "nullish"
            | "optional"
            | "set"
            | "undefinedable"
            | "tuple"
            | "union"
            | "variant"
            | "intersect"
            | "record"
            | "nan"
            | "non_nullable"
            | "non_nullish"
            | "non_optional"
            | "strict_tuple"
            | "loose_tuple"
            | "strict_object"
            | "loose_object"
            | "tuple_with_rest"
            | "object_with_rest"]: Arbitrary<
                {
                    any: [10];
                    array: [1000, unknown, Bounds_array];
                    bigint: [150, Bounds_bigint];
                    blob: [27];
                    boolean: [15];
                    custom: [9500, unknown];
                    date: [20];
                    enum: [500, any];
                    file: [25];
                    intersect: [6000, [[7500, (...)[]], [7500, (...)[]]]];
                    lazy: [10500, (...args: []) => unknown];
                    literal: [550, string | number | boolean];
                    loose_object: [7600, [string, unknown][]];
                    loose_tuple: [8100, unknown[]];
                    map: [6500, [unknown, unknown]];
                    nan: [30];
                    never: [35];
                    non_nullable: [2100, unknown];
                    non_nullish: [2300, unknown];
                    non_optional: [1500, unknown];
                    null: [40];
                    nullable: [2000, unknown];
                    nullish: [2200, unknown];
                    number: [200, Bounds_number];
                    object: [7500, [string, unknown][]];
                    object_with_rest: [7800, [string, unknown][], unknown];
                    optional: [2500, unknown];
                    promise: unknown;
                    record: [7000, unknown];
                    set: [3500, unknown];
                    strict_object: [7700, [string, unknown][]];
                    strict_tuple: [8200, unknown[]];
                    string: [250, Bounds_string];
                    symbol: [45];
                    tuple: [8000, unknown[]];
                    tuple_with_rest: [8300, unknown[], unknown];
                    undefined: [50];
                    undefinedable: [2700, unknown];
                    union: [8500, unknown[]];
                    unknown: [55];
                    variant: [8600, [string, (...)[]][], string];
                    void: [60];
                }[K],
            >
        },
    > = ...

    Pseudo-random seed generator.

    The generator supports a wide range of discoverable configuration options via the optional options argument.

    Many of those options are forwarded to the corresponding fast-check arbitrary.

    Note: support for options.minDepth is experimental. If you use it, be advised that even with a minimum depth of 1, the schemas produced will be quite large. Using this option in your CI/CD pipeline is not recommended.

    See also:

    Type declaration

      • <
            Options extends
                GeneratorOptions<
                    {
                        any: [10];
                        array: [1000, unknown, Bounds_array];
                        bigint: [150, Bounds_bigint];
                        blob: [27];
                        boolean: [15];
                        custom: [9500, unknown];
                        date: [20];
                        enum: [500, any];
                        file: [25];
                        intersect: [
                            6000,
                            [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                        ];
                        lazy: [10500, (...args: []) => unknown];
                        literal: [550, string | number | boolean];
                        loose_object: [7600, [string, unknown][]];
                        loose_tuple: [8100, unknown[]];
                        map: [6500, [unknown, unknown]];
                        nan: [30];
                        never: [35];
                        non_nullable: [2100, unknown];
                        non_nullish: [2300, unknown];
                        non_optional: [1500, unknown];
                        null: [40];
                        nullable: [2000, unknown];
                        nullish: [2200, unknown];
                        number: [200, Bounds_number];
                        object: [7500, [string, unknown][]];
                        object_with_rest: [7800, [string, unknown][], unknown];
                        optional: [2500, unknown];
                        promise: unknown;
                        record: [7000, unknown];
                        set: [3500, unknown];
                        strict_object: [7700, [string, unknown][]];
                        strict_tuple: [8200, unknown[]];
                        string: [250, Bounds_string];
                        symbol: [45];
                        tuple: [8000, unknown[]];
                        tuple_with_rest: [8300, unknown[], unknown];
                        undefined: [50];
                        undefinedable: [2700, unknown];
                        union: [8500, unknown[]];
                        unknown: [55];
                        variant: [8600, [string, [string, unknown][]][], string];
                        void: [60];
                    },
                >,
        >(
            options?: Options,
            overrides?: Partial<
                Gen.Base<
                    {
                        any: [10];
                        array: [1000, unknown, Bounds_array];
                        bigint: [150, Bounds_bigint];
                        blob: [27];
                        boolean: [15];
                        custom: [9500, unknown];
                        date: [20];
                        enum: [500, any];
                        file: [25];
                        intersect: [
                            6000,
                            [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                        ];
                        lazy: [10500, (...args: []) => unknown];
                        literal: [550, string | number | boolean];
                        loose_object: [7600, [string, unknown][]];
                        loose_tuple: [8100, unknown[]];
                        map: [6500, [unknown, unknown]];
                        nan: [30];
                        never: [35];
                        non_nullable: [2100, unknown];
                        non_nullish: [2300, unknown];
                        non_optional: [1500, unknown];
                        null: [40];
                        nullable: [2000, unknown];
                        nullish: [2200, unknown];
                        number: [200, Bounds_number];
                        object: [7500, [string, unknown][]];
                        object_with_rest: [7800, [string, unknown][], unknown];
                        optional: [2500, unknown];
                        promise: unknown;
                        record: [7000, unknown];
                        set: [3500, unknown];
                        strict_object: [7700, [string, unknown][]];
                        strict_tuple: [8200, unknown[]];
                        string: [250, Bounds_string];
                        symbol: [45];
                        tuple: [8000, unknown[]];
                        tuple_with_rest: [8300, unknown[], unknown];
                        undefined: [50];
                        undefinedable: [2700, unknown];
                        union: [8500, unknown[]];
                        unknown: [55];
                        variant: [8600, [string, [string, unknown][]][], string];
                        void: [60];
                    },
                    byTypeName,
                >,
            >,
        ): Gen.Builder<
            (
                [
                    Options["root"] extends | "string"
                    | "number"
                    | "bigint"
                    | "boolean"
                    | "symbol"
                    | "undefined"
                    | "object"
                    | "map"
                    | "any"
                    | "blob"
                    | "custom"
                    | "date"
                    | "file"
                    | "never"
                    | "null"
                    | "promise"
                    | "unknown"
                    | "void"
                    | "enum"
                    | "literal"
                    | "lazy"
                    | "array"
                    | "nullable"
                    | "nullish"
                    | "optional"
                    | "set"
                    | "undefinedable"
                    | "tuple"
                    | "union"
                    | "variant"
                    | "intersect"
                    | "record"
                    | "nan"
                    | "non_nullable"
                    | "non_nullish"
                    | "non_optional"
                    | "strict_tuple"
                    | "loose_tuple"
                    | "strict_object"
                    | "loose_object"
                    | "tuple_with_rest"
                    | "object_with_rest"
                        ? {
                            any: [10];
                            array: [1000, unknown, Bounds_array];
                            bigint: [150, Bounds_bigint];
                            blob: [27];
                            boolean: [15];
                            custom: [9500, unknown];
                            date: [20];
                            enum: [500, any];
                            file: [25];
                            intersect: [6000, [[(...), (...)], [(...), (...)]]];
                            lazy: [10500, (...args: []) => unknown];
                            literal: [550, string | number | boolean];
                            loose_object: [7600, [(...), (...)][]];
                            loose_tuple: [8100, unknown[]];
                            map: [6500, [unknown, unknown]];
                            nan: [30];
                            never: [35];
                            non_nullable: [2100, unknown];
                            non_nullish: [2300, unknown];
                            non_optional: [1500, unknown];
                            null: [40];
                            nullable: [2000, unknown];
                            nullish: [2200, unknown];
                            number: [200, Bounds_number];
                            object: [7500, [(...), (...)][]];
                            object_with_rest: [7800, [(...), (...)][], unknown];
                            optional: [2500, unknown];
                            promise: unknown;
                            record: [7000, unknown];
                            set: [3500, unknown];
                            strict_object: [7700, [(...), (...)][]];
                            strict_tuple: [8200, unknown[]];
                            string: [250, Bounds_string];
                            symbol: [45];
                            tuple: [8000, unknown[]];
                            tuple_with_rest: [8300, unknown[], unknown];
                            undefined: [50];
                            undefinedable: [2700, unknown];
                            union: [8500, unknown[]];
                            unknown: [55];
                            variant: [8600, [(...), (...)][], string];
                            void: [60];
                        }[any[any]]
                        : never,
                ] extends [never]
                    ? unknown
                    : {
                        root: Arbitrary<
                            Options["root"] extends | "string"
                            | "number"
                            | "bigint"
                            | "boolean"
                            | "symbol"
                            | "undefined"
                            | "object"
                            | "map"
                            | "any"
                            | "blob"
                            | "custom"
                            | "date"
                            | "file"
                            | "never"
                            | "null"
                            | "promise"
                            | "unknown"
                            | "void"
                            | "enum"
                            | "literal"
                            | "lazy"
                            | "array"
                            | "nullable"
                            | "nullish"
                            | "optional"
                            | "set"
                            | "undefinedable"
                            | "tuple"
                            | "union"
                            | "variant"
                            | "intersect"
                            | "record"
                            | "nan"
                            | "non_nullable"
                            | "non_nullish"
                            | "non_optional"
                            | "strict_tuple"
                            | "loose_tuple"
                            | "strict_object"
                            | "loose_object"
                            | "tuple_with_rest"
                            | "object_with_rest"
                                ? {
                                    any: [10];
                                    array: [1000, unknown, Bounds_array];
                                    bigint: [150, Bounds_bigint];
                                    blob: [27];
                                    boolean: [15];
                                    custom: [9500, unknown];
                                    date: [20];
                                    enum: [500, any];
                                    file: [25];
                                    intersect: [6000, [(...), (...)]];
                                    lazy: [10500, (...args: ...) => ...];
                                    literal: [550, (...) | (...) | (...) | (...)];
                                    loose_object: [7600, (...)[]];
                                    loose_tuple: [8100, (...)[]];
                                    map: [6500, [(...), (...)]];
                                    nan: [30];
                                    never: [35];
                                    non_nullable: [2100, unknown];
                                    non_nullish: [2300, unknown];
                                    non_optional: [1500, unknown];
                                    null: [40];
                                    nullable: [2000, unknown];
                                    nullish: [2200, unknown];
                                    number: [200, Bounds_number];
                                    object: [7500, (...)[]];
                                    object_with_rest: [7800, (...)[], unknown];
                                    optional: [2500, unknown];
                                    promise: unknown;
                                    record: [7000, unknown];
                                    set: [3500, unknown];
                                    strict_object: [7700, (...)[]];
                                    strict_tuple: [8200, (...)[]];
                                    string: [250, Bounds_string];
                                    symbol: [45];
                                    tuple: [8000, (...)[]];
                                    tuple_with_rest: [8300, (...)[], unknown];
                                    undefined: [50];
                                    undefinedable: [2700, unknown];
                                    union: [8500, (...)[]];
                                    unknown: [55];
                                    variant: [8600, (...)[], string];
                                    void: [60];
                                }[any[any]]
                                : never,
                        >;
                    }
            ) & {
                [K in | "string"
                | "number"
                | "bigint"
                | "boolean"
                | "symbol"
                | "undefined"
                | "object"
                | "map"
                | "any"
                | "blob"
                | "custom"
                | "date"
                | "file"
                | "never"
                | "null"
                | "promise"
                | "unknown"
                | "void"
                | "enum"
                | "literal"
                | "lazy"
                | "array"
                | "nullable"
                | "nullish"
                | "optional"
                | "set"
                | "undefinedable"
                | "tuple"
                | "union"
                | "variant"
                | "intersect"
                | "record"
                | "nan"
                | "non_nullable"
                | "non_nullish"
                | "non_optional"
                | "strict_tuple"
                | "loose_tuple"
                | "strict_object"
                | "loose_object"
                | "tuple_with_rest"
                | "object_with_rest"]: Arbitrary<
                    {
                        any: [10];
                        array: [1000, unknown, Bounds_array];
                        bigint: [150, Bounds_bigint];
                        blob: [27];
                        boolean: [15];
                        custom: [9500, unknown];
                        date: [20];
                        enum: [500, any];
                        file: [25];
                        intersect: [6000, [[7500, (...)[]], [7500, (...)[]]]];
                        lazy: [10500, (...args: []) => unknown];
                        literal: [550, string | number | boolean];
                        loose_object: [7600, [string, unknown][]];
                        loose_tuple: [8100, unknown[]];
                        map: [6500, [unknown, unknown]];
                        nan: [30];
                        never: [35];
                        non_nullable: [2100, unknown];
                        non_nullish: [2300, unknown];
                        non_optional: [1500, unknown];
                        null: [40];
                        nullable: [2000, unknown];
                        nullish: [2200, unknown];
                        number: [200, Bounds_number];
                        object: [7500, [string, unknown][]];
                        object_with_rest: [7800, [string, unknown][], unknown];
                        optional: [2500, unknown];
                        promise: unknown;
                        record: [7000, unknown];
                        set: [3500, unknown];
                        strict_object: [7700, [string, unknown][]];
                        strict_tuple: [8200, unknown[]];
                        string: [250, Bounds_string];
                        symbol: [45];
                        tuple: [8000, unknown[]];
                        tuple_with_rest: [8300, unknown[], unknown];
                        undefined: [50];
                        undefinedable: [2700, unknown];
                        union: [8500, unknown[]];
                        unknown: [55];
                        variant: [8600, [string, (...)[]][], string];
                        void: [60];
                    }[K],
                >
            },
        >

      • Type Parameters

        • Options extends GeneratorOptions<
              {
                  any: [10];
                  array: [1000, unknown, Bounds_array];
                  bigint: [150, Bounds_bigint];
                  blob: [27];
                  boolean: [15];
                  custom: [9500, unknown];
                  date: [20];
                  enum: [500, any];
                  file: [25];
                  intersect: [
                      6000,
                      [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                  ];
                  lazy: [10500, (...args: []) => unknown];
                  literal: [550, string | number | boolean];
                  loose_object: [7600, [string, unknown][]];
                  loose_tuple: [8100, unknown[]];
                  map: [6500, [unknown, unknown]];
                  nan: [30];
                  never: [35];
                  non_nullable: [2100, unknown];
                  non_nullish: [2300, unknown];
                  non_optional: [1500, unknown];
                  null: [40];
                  nullable: [2000, unknown];
                  nullish: [2200, unknown];
                  number: [200, Bounds_number];
                  object: [7500, [string, unknown][]];
                  object_with_rest: [7800, [string, unknown][], unknown];
                  optional: [2500, unknown];
                  promise: unknown;
                  record: [7000, unknown];
                  set: [3500, unknown];
                  strict_object: [7700, [string, unknown][]];
                  strict_tuple: [8200, unknown[]];
                  string: [250, Bounds_string];
                  symbol: [45];
                  tuple: [8000, unknown[]];
                  tuple_with_rest: [8300, unknown[], unknown];
                  undefined: [50];
                  undefinedable: [2700, unknown];
                  union: [8500, unknown[]];
                  unknown: [55];
                  variant: [8600, [string, [string, unknown][]][], string];
                  void: [60];
              },
          >

        Parameters

        • Optionaloptions: Options
        • Optionaloverrides: Partial<
              Gen.Base<
                  {
                      any: [10];
                      array: [1000, unknown, Bounds_array];
                      bigint: [150, Bounds_bigint];
                      blob: [27];
                      boolean: [15];
                      custom: [9500, unknown];
                      date: [20];
                      enum: [500, any];
                      file: [25];
                      intersect: [
                          6000,
                          [[7500, [string, unknown][]], [7500, [string, unknown][]]],
                      ];
                      lazy: [10500, (...args: []) => unknown];
                      literal: [550, string | number | boolean];
                      loose_object: [7600, [string, unknown][]];
                      loose_tuple: [8100, unknown[]];
                      map: [6500, [unknown, unknown]];
                      nan: [30];
                      never: [35];
                      non_nullable: [2100, unknown];
                      non_nullish: [2300, unknown];
                      non_optional: [1500, unknown];
                      null: [40];
                      nullable: [2000, unknown];
                      nullish: [2200, unknown];
                      number: [200, Bounds_number];
                      object: [7500, [string, unknown][]];
                      object_with_rest: [7800, [string, unknown][], unknown];
                      optional: [2500, unknown];
                      promise: unknown;
                      record: [7000, unknown];
                      set: [3500, unknown];
                      strict_object: [7700, [string, unknown][]];
                      strict_tuple: [8200, unknown[]];
                      string: [250, Bounds_string];
                      symbol: [45];
                      tuple: [8000, unknown[]];
                      tuple_with_rest: [8300, unknown[], unknown];
                      undefined: [50];
                      undefinedable: [2700, unknown];
                      union: [8500, unknown[]];
                      unknown: [55];
                      variant: [8600, [string, [string, unknown][]][], string];
                      void: [60];
                  },
                  byTypeName,
              >,
          >

        Returns Gen.Builder<
            (
                [
                    Options["root"] extends | "string"
                    | "number"
                    | "bigint"
                    | "boolean"
                    | "symbol"
                    | "undefined"
                    | "object"
                    | "map"
                    | "any"
                    | "blob"
                    | "custom"
                    | "date"
                    | "file"
                    | "never"
                    | "null"
                    | "promise"
                    | "unknown"
                    | "void"
                    | "enum"
                    | "literal"
                    | "lazy"
                    | "array"
                    | "nullable"
                    | "nullish"
                    | "optional"
                    | "set"
                    | "undefinedable"
                    | "tuple"
                    | "union"
                    | "variant"
                    | "intersect"
                    | "record"
                    | "nan"
                    | "non_nullable"
                    | "non_nullish"
                    | "non_optional"
                    | "strict_tuple"
                    | "loose_tuple"
                    | "strict_object"
                    | "loose_object"
                    | "tuple_with_rest"
                    | "object_with_rest"
                        ? {
                            any: [10];
                            array: [1000, unknown, Bounds_array];
                            bigint: [150, Bounds_bigint];
                            blob: [27];
                            boolean: [15];
                            custom: [9500, unknown];
                            date: [20];
                            enum: [500, any];
                            file: [25];
                            intersect: [6000, [[(...), (...)], [(...), (...)]]];
                            lazy: [10500, (...args: []) => unknown];
                            literal: [550, string | number | boolean];
                            loose_object: [7600, [(...), (...)][]];
                            loose_tuple: [8100, unknown[]];
                            map: [6500, [unknown, unknown]];
                            nan: [30];
                            never: [35];
                            non_nullable: [2100, unknown];
                            non_nullish: [2300, unknown];
                            non_optional: [1500, unknown];
                            null: [40];
                            nullable: [2000, unknown];
                            nullish: [2200, unknown];
                            number: [200, Bounds_number];
                            object: [7500, [(...), (...)][]];
                            object_with_rest: [7800, [(...), (...)][], unknown];
                            optional: [2500, unknown];
                            promise: unknown;
                            record: [7000, unknown];
                            set: [3500, unknown];
                            strict_object: [7700, [(...), (...)][]];
                            strict_tuple: [8200, unknown[]];
                            string: [250, Bounds_string];
                            symbol: [45];
                            tuple: [8000, unknown[]];
                            tuple_with_rest: [8300, unknown[], unknown];
                            undefined: [50];
                            undefinedable: [2700, unknown];
                            union: [8500, unknown[]];
                            unknown: [55];
                            variant: [8600, [(...), (...)][], string];
                            void: [60];
                        }[any[any]]
                        : never,
                ] extends [never]
                    ? unknown
                    : {
                        root: Arbitrary<
                            Options["root"] extends | "string"
                            | "number"
                            | "bigint"
                            | "boolean"
                            | "symbol"
                            | "undefined"
                            | "object"
                            | "map"
                            | "any"
                            | "blob"
                            | "custom"
                            | "date"
                            | "file"
                            | "never"
                            | "null"
                            | "promise"
                            | "unknown"
                            | "void"
                            | "enum"
                            | "literal"
                            | "lazy"
                            | "array"
                            | "nullable"
                            | "nullish"
                            | "optional"
                            | "set"
                            | "undefinedable"
                            | "tuple"
                            | "union"
                            | "variant"
                            | "intersect"
                            | "record"
                            | "nan"
                            | "non_nullable"
                            | "non_nullish"
                            | "non_optional"
                            | "strict_tuple"
                            | "loose_tuple"
                            | "strict_object"
                            | "loose_object"
                            | "tuple_with_rest"
                            | "object_with_rest"
                                ? {
                                    any: [10];
                                    array: [1000, unknown, Bounds_array];
                                    bigint: [150, Bounds_bigint];
                                    blob: [27];
                                    boolean: [15];
                                    custom: [9500, unknown];
                                    date: [20];
                                    enum: [500, any];
                                    file: [25];
                                    intersect: [6000, [(...), (...)]];
                                    lazy: [10500, (...args: ...) => ...];
                                    literal: [550, (...) | (...) | (...) | (...)];
                                    loose_object: [7600, (...)[]];
                                    loose_tuple: [8100, (...)[]];
                                    map: [6500, [(...), (...)]];
                                    nan: [30];
                                    never: [35];
                                    non_nullable: [2100, unknown];
                                    non_nullish: [2300, unknown];
                                    non_optional: [1500, unknown];
                                    null: [40];
                                    nullable: [2000, unknown];
                                    nullish: [2200, unknown];
                                    number: [200, Bounds_number];
                                    object: [7500, (...)[]];
                                    object_with_rest: [7800, (...)[], unknown];
                                    optional: [2500, unknown];
                                    promise: unknown;
                                    record: [7000, unknown];
                                    set: [3500, unknown];
                                    strict_object: [7700, (...)[]];
                                    strict_tuple: [8200, (...)[]];
                                    string: [250, Bounds_string];
                                    symbol: [45];
                                    tuple: [8000, (...)[]];
                                    tuple_with_rest: [8300, (...)[], unknown];
                                    undefined: [50];
                                    undefinedable: [2700, unknown];
                                    union: [8500, (...)[]];
                                    unknown: [55];
                                    variant: [8600, (...)[], string];
                                    void: [60];
                                }[any[any]]
                                : never,
                        >;
                    }
            ) & {
                [K in | "string"
                | "number"
                | "bigint"
                | "boolean"
                | "symbol"
                | "undefined"
                | "object"
                | "map"
                | "any"
                | "blob"
                | "custom"
                | "date"
                | "file"
                | "never"
                | "null"
                | "promise"
                | "unknown"
                | "void"
                | "enum"
                | "literal"
                | "lazy"
                | "array"
                | "nullable"
                | "nullish"
                | "optional"
                | "set"
                | "undefinedable"
                | "tuple"
                | "union"
                | "variant"
                | "intersect"
                | "record"
                | "nan"
                | "non_nullable"
                | "non_nullish"
                | "non_optional"
                | "strict_tuple"
                | "loose_tuple"
                | "strict_object"
                | "loose_object"
                | "tuple_with_rest"
                | "object_with_rest"]: Arbitrary<
                    {
                        any: [10];
                        array: [1000, unknown, Bounds_array];
                        bigint: [150, Bounds_bigint];
                        blob: [27];
                        boolean: [15];
                        custom: [9500, unknown];
                        date: [20];
                        enum: [500, any];
                        file: [25];
                        intersect: [6000, [[7500, (...)[]], [7500, (...)[]]]];
                        lazy: [10500, (...args: []) => unknown];
                        literal: [550, string | number | boolean];
                        loose_object: [7600, [string, unknown][]];
                        loose_tuple: [8100, unknown[]];
                        map: [6500, [unknown, unknown]];
                        nan: [30];
                        never: [35];
                        non_nullable: [2100, unknown];
                        non_nullish: [2300, unknown];
                        non_optional: [1500, unknown];
                        null: [40];
                        nullable: [2000, unknown];
                        nullish: [2200, unknown];
                        number: [200, Bounds_number];
                        object: [7500, [string, unknown][]];
                        object_with_rest: [7800, [string, unknown][], unknown];
                        optional: [2500, unknown];
                        promise: unknown;
                        record: [7000, unknown];
                        set: [3500, unknown];
                        strict_object: [7700, [string, unknown][]];
                        strict_tuple: [8200, unknown[]];
                        string: [250, Bounds_string];
                        symbol: [45];
                        tuple: [8000, unknown[]];
                        tuple_with_rest: [8300, unknown[], unknown];
                        undefined: [50];
                        undefinedable: [2700, unknown];
                        union: [8500, unknown[]];
                        unknown: [55];
                        variant: [8600, [string, (...)[]][], string];
                        void: [60];
                    }[K],
                >
            },
        >

    import * as fc from 'fast-check'
    import * as v from 'valibot'
    import { vxTest } from '@traversable/valibot-test'

    const Json = vxTest.SeedGenerator({ include: ['null', 'boolean', 'number', 'string', 'array', 'object'] })
    const [jsonNumber, jsonObject, anyJson] = [
      fc.sample(Json.number, 1)[0],
      fc.sample(Json.object, 1)[0],
      fc.sample(Json['*'], 1)[0],
    ] as const

    console.log(JSON.stringify(jsonNumber))
    // => [200,[2.96e-322,1,null,false,true]]

    console.log(vxTest.toString(vxTest.seedToSchema(jsonNumber)))
    // => v.pipe(v.number(), v.maxValue(2.96e-322), v.ltValue(1)

    console.log(JSON.stringify(jsonObject))
    // => [7500,[["n;}289K~",[250,[null,null]]]]]

    console.log(vxTest.toString(vxTest.seedToSchema(jsonObject)))
    // => v.object({ "n;}289K~": v.string() })

    console.log(anyJson)
    // => [250,[23,64]]

    console.log(vxTest.toString(vxTest.seedToSchema(anyJson)))
    // => v.pipe(v.string(), v.minValue(23), v.maxValue(64))

    Settings

    Member Visibility

    On This Page

    <a href="#" class="tsd-kind-variable">SeedGenerator</a>