@traversable/schema
    Preparing search index...

    Variable SchemaGeneratorConst

    SchemaGenerator: <
        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];
                },
            >,
    >(
        ...a: [
            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, [(...), (...)][]], [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];
                    },
                    byTypeName,
                >,
            >,
        ],
    ) => Arbitrary = ...

    A valibot schema generator that can be interpreted to produce an arbitrary valibot schema.

    The generator supports a wide range of configuration options that are discoverable 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];
                    },
                >,
        >(
            ...a: [
                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, [(...), (...)][]], [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];
                        },
                        byTypeName,
                    >,
                >,
            ],
        ): Arbitrary

      • 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

        • ...a: [
              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, [(...), (...)][]], [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];
                      },
                      byTypeName,
                  >,
              >,
          ]

        Returns Arbitrary

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

    const tenSchemas = fc.sample(vxTest.SchemaGenerator({
      include: ['null', 'boolean', 'number', 'string', 'array', 'object'] 
    }), 10)

    tenSchemas.forEach((s) => console.log(vxTest.toString(s)))
    // => v.number()
    // => v.pipe(v.string(), v.minValue(9.1e-53))
    // => v.null()
    // => v.array(v.boolean())
    // => v.boolean()
    // => v.object({ "": v.object({ "/d2P} {/": v.boolean() }), "svH2]L'x": v.pipe(v.number(), v.ltValue(-65536)) })
    // => v.null()
    // => v.string()
    // => v.array(v.array(v.null()))
    // => v.object({ "y(Qza": v.boolean(), "G1S\\U 4Y6i": v.object({ "YtO3]ia0cM": v.boolean() }) })

    Settings

    Member Visibility

    On This Page

    <a href="#" class="tsd-kind-variable">vxTest.SchemaGenerator</a>