tinybase 9.4.0 → 9.5.0-beta.1

package/@types/schematizers/schematizer-typebox/with-schemas/index.d.ts

@@ -5,4 +5,117 @@
  * @module schematizer-typebox
  * @since v7.1.0
  */
-export type {TypeBoxSchematizer, createTypeBoxSchematizer} from '../index.d.ts';
+import type {
+  TablesSchema,
+  ValuesSchema,
+} from '../../../store/with-schemas/index.d.ts';
+import type {Schematizer} from '../../with-schemas/index.d.ts';
+
+/**
+ * The TypeBoxSchematizer interface represents a schematizer specifically for
+ * converting TypeBox schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface TypeBoxSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of TypeBox object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive enums and literals, default values, nullable flags,
+ * and required flags from TypeBox schemas. Complex validation rules like
+ * min/max, patterns, formats, and custom validators are ignored.
+ * @param schemas - A mapping of table IDs to TypeBox object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts TypeBox schemas to TinyBase format.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createStore} from 'tinybase';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Type.Object({
+ *     species: Type.String(),
+ *     age: Type.Number(),
+ *     sold: Type.Boolean({default: false}),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of TypeBox schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive enums and literals, default values, nullable flags,
+ * and required flags from TypeBox schemas.
+ * @param schemas - A mapping of value IDs to TypeBox schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts TypeBox schemas to TinyBase ValuesSchema format.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createStore} from 'tinybase';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: Type.String({default: 'light'}),
+ *   count: Type.Number(),
+ *   isOpen: Type.Boolean(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * store.setValues({count: 42, isOpen: true});
+ * console.log(store.getValues());
+ * // -> {theme: 'light', count: 42, isOpen: true}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createTypeBoxSchematizer function creates a TypeBoxSchematizer object
+ * that can convert TypeBox schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new TypeBoxSchematizer instance.
+ * @example
+ * This example creates a TypeBox schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Type.Object({
+ *     species: Type.String(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string', required: true}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createTypeBoxSchematizer(): TypeBoxSchematizer;

package/@types/schematizers/schematizer-valibot/index.d.ts

@@ -19,10 +19,10 @@ export interface ValibotSchematizer extends Schematizer {
  * The toTablesSchema method converts a mapping of Valibot object schemas into a
  * TinyBase TablesSchema.
  *
- * This method extracts basic type information (string, number, boolean),
- * string picklists, fallback values, nullable flags, and required flags from
- * Valibot schemas. Complex validation rules like min/max, regex patterns,
- * refinements, and transforms are ignored.
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive picklists and literal unions, fallback values,
+ * nullable flags, and required flags from Valibot schemas. Complex validation
+ * rules like min/max, regex patterns, refinements, and transforms are ignored.
  * @param schemas - A mapping of table IDs to Valibot object schemas.
  * @returns A TinyBase TablesSchema.
  * @example
@@ -57,8 +57,8 @@ export interface ValibotSchematizer extends Schematizer {
  * The toValuesSchema method converts a mapping of Valibot schemas into a
  * TinyBase ValuesSchema.
  *
- * This method extracts basic type information, string picklists, fallback
- * values, and required flags from Valibot schemas.
+ * This method extracts basic type information and unions, primitive picklists
+ * and literal unions, fallback values, and required flags from Valibot schemas.
  * @param schemas - A mapping of value IDs to Valibot schemas.
  * @returns A TinyBase ValuesSchema.
  * @example

package/@types/schematizers/schematizer-valibot/with-schemas/index.d.ts

@@ -5,4 +5,115 @@
  * @module schematizer-valibot
  * @since v7.1.0
  */
-export type {ValibotSchematizer} from '../index.d.ts';
+import type {
+  TablesSchema,
+  ValuesSchema,
+} from '../../../store/with-schemas/index.d.ts';
+import type {Schematizer} from '../../with-schemas/index.d.ts';
+
+/**
+ * The ValibotSchematizer interface represents a schematizer specifically for
+ * converting Valibot schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface ValibotSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Valibot object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive picklists and literal unions, fallback values,
+ * nullable flags, and required flags from Valibot schemas. Complex validation
+ * rules like min/max, regex patterns, refinements, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to Valibot object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Valibot schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {boolean, fallback, number, object, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *     age: number(),
+ *     sold: fallback(boolean(), false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Valibot schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information and unions, primitive picklists
+ * and literal unions, fallback values, and required flags from Valibot schemas.
+ * @param schemas - A mapping of value IDs to Valibot schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Valibot value schemas.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {fallback, number, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: fallback(string(), 'light'),
+ *   count: number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * store.setValues({count: 1});
+ * console.log(store.getValues());
+ * // -> {theme: 'light', count: 1}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createValibotSchematizer function creates a ValibotSchematizer object
+ * that can convert Valibot schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new ValibotSchematizer instance.
+ * @example
+ * This example creates a Valibot schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {object, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string', required: true}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createValibotSchematizer(): ValibotSchematizer;

package/@types/schematizers/schematizer-yup/index.d.ts

@@ -19,8 +19,9 @@ export interface YupSchematizer extends Schematizer {
  * TinyBase TablesSchema.
  *
  * This method extracts basic type information (string, number, boolean),
- * string enums, default values, nullable flags, and required flags from Yup
- * schemas. Complex validation rules like min/max, regex patterns, tests, and
+ * primitive enums and literals, default values, nullable flags, and required
+ * flags from Yup schemas. Complex validation rules like min/max, regex
+ * patterns, tests, and
  * transforms are ignored.
  * @param schemas - A mapping of table IDs to Yup object schemas.
  * @returns A TinyBase TablesSchema.
@@ -57,8 +58,8 @@ export interface YupSchematizer extends Schematizer {
  * ValuesSchema.
  *
  * This method extracts basic type information (string, number, boolean),
- * string enums, default values, nullable flags, and required flags from Yup
- * schemas.
+ * primitive enums and literals, default values, nullable flags, and required
+ * flags from Yup schemas.
  * @param schemas - A mapping of value IDs to Yup schemas.
  * @returns A TinyBase ValuesSchema.
  * @example

package/@types/schematizers/schematizer-yup/with-schemas/index.d.ts

@@ -4,4 +4,115 @@
  * @module schematizer-yup
  * @since v7.1.0
  */
-export type {YupSchematizer, createYupSchematizer} from '../index.d.ts';
+import type {
+  TablesSchema,
+  ValuesSchema,
+} from '../../../store/with-schemas/index.d.ts';
+import type {Schematizer} from '../../with-schemas/index.d.ts';
+
+/**
+ * The YupSchematizer interface represents a schematizer specifically for
+ * converting Yup schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface YupSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Yup object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * primitive enums and literals, default values, nullable flags, and required
+ * flags from Yup schemas. Complex validation rules like min/max, regex
+ * patterns, tests, and
+ * transforms are ignored.
+ * @param schemas - A mapping of table IDs to Yup object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Yup schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {boolean, number, object, string} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *     age: number(),
+ *     sold: boolean().default(false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Yup schemas into a TinyBase
+ * ValuesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * primitive enums and literals, default values, nullable flags, and required
+ * flags from Yup schemas.
+ * @param schemas - A mapping of value IDs to Yup schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Yup schemas to TinyBase values.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {boolean, number} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   open: boolean().default(true),
+ *   employees: number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * console.log(store.getValues());
+ * // -> {open: true}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createYupSchematizer function creates a YupSchematizer instance for
+ * converting Yup schemas to TinyBase schemas.
+ * @returns A new YupSchematizer instance.
+ * @example
+ * This example creates a Yup schematizer.
+ *
+ * ```js
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {object, string} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *   }),
+ * });
+ *
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createYupSchematizer(): YupSchematizer;

package/@types/schematizers/schematizer-zod/index.d.ts

@@ -18,10 +18,10 @@ export interface ZodSchematizer extends Schematizer {
  * The toTablesSchema method converts a mapping of Zod object schemas into a
  * TinyBase TablesSchema.
  *
- * This method extracts basic type information (string, number, boolean),
- * string enums, default values, nullable flags, and required flags from Zod
- * schemas. Complex validation rules like min/max, regex patterns,
- * refinements, and transforms are ignored.
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive enums and literals, default values, nullable flags,
+ * and required flags from Zod schemas. Complex validation rules like min/max,
+ * regex patterns, refinements, and transforms are ignored.
  * @param schemas - A mapping of table IDs to Zod object schemas.
  * @returns A TinyBase TablesSchema.
  * @example
@@ -56,8 +56,8 @@ export interface ZodSchematizer extends Schematizer {
  * The toValuesSchema method converts a mapping of Zod schemas into a TinyBase
  * ValuesSchema.
  *
- * This method extracts basic type information, string enums, default values,
- * and required flags from Zod schemas.
+ * This method extracts basic type information and unions, primitive enums and
+ * literals, default values, and required flags from Zod schemas.
  * @param schemas - A mapping of value IDs to Zod schemas.
  * @returns A TinyBase ValuesSchema.
  * @example

package/@types/schematizers/schematizer-zod/with-schemas/index.d.ts

@@ -4,4 +4,115 @@
  * @module schematizer-zod
  * @since v7.1.0
  */
-export type {ZodSchematizer, createZodSchematizer} from '../index.d.ts';
+import type {
+  TablesSchema,
+  ValuesSchema,
+} from '../../../store/with-schemas/index.d.ts';
+import type {Schematizer} from '../../with-schemas/index.d.ts';
+
+/**
+ * The ZodSchematizer interface represents a schematizer specifically for
+ * converting Zod schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface ZodSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Zod object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean), basic
+ * type unions, primitive enums and literals, default values, nullable flags,
+ * and required flags from Zod schemas. Complex validation rules like min/max,
+ * regex patterns, refinements, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to Zod object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Zod schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: z.object({
+ *     species: z.enum(['dog', 'cat']),
+ *     age: z.number(),
+ *     sold: z.boolean().default(false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Zod schemas into a TinyBase
+ * ValuesSchema.
+ *
+ * This method extracts basic type information and unions, primitive enums and
+ * literals, default values, and required flags from Zod schemas.
+ * @param schemas - A mapping of value IDs to Zod schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Zod value schemas.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: z.string().default('light'),
+ *   count: z.number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * store.setValues({count: 1});
+ * console.log(store.getValues());
+ * // -> {theme: 'light', count: 1}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createZodSchematizer function creates a ZodSchematizer object that can
+ * convert Zod schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new ZodSchematizer instance.
+ * @example
+ * This example creates a Zod schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: z.object({
+ *     species: z.string(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string', required: true}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createZodSchematizer(): ZodSchematizer;

package/@types/schematizers/with-schemas/index.d.ts

@@ -2,11 +2,120 @@
  * The schematizers module provides utilities for converting schemas from
  * popular validation libraries into TinyBase's schema format.
  *
- * Schematizers perform "best-effort" conversion, extracting basic type
- * information (string, number, boolean) and default values while discarding
- * complex validation rules that TinyBase doesn't support.
+ * Schematizers perform "best-effort" conversion, extracting basic type and
+ * type union, primitive enum and literal, and default information while
+ * discarding complex validation rules that TinyBase doesn't support.
  * @packageDocumentation
  * @module schematizers
  * @since v7.1.0
  */
-export type {Schematizer} from '../index.d.ts';
+import type {
+  TablesSchema,
+  ValuesSchema,
+} from '../../store/with-schemas/index.d.ts';
+
+/**
+ * The Schematizer interface represents a schema converter that can transform
+ * external validation library schemas into TinyBase TablesSchema and
+ * ValuesSchema formats.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of external schemas into a
+ * TinyBase TablesSchema.
+ * @param schemas - A mapping of table IDs to external schema objects.
+ * @returns A TinyBase TablesSchema.
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: any): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of external schemas into a
+ * TinyBase ValuesSchema.
+ * @param schemas - A mapping of value IDs to external schema objects.
+ * @returns A TinyBase ValuesSchema.
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: any): ValuesSchema;
+}
+
+/**
+ * The createCustomSchematizer function creates a custom Schematizer that can
+ * convert schemas from any validation library into TinyBase schemas.
+ *
+ * This function allows you to build schematizers for validation libraries not
+ * natively supported by TinyBase. You provide two functions: one to unwrap
+ * optional/nullable/default wrappers from your library's schemas, and one to
+ * extract object properties.
+ * @param unwrapSchema - A function that unwraps a schema to extract the base
+ * type, default value, nullable flag, and optional required flag. It should
+ * recursively unwrap optional/nullable wrappers and return a tuple of
+ * [schema, defaultValue, allowNull, required]. The unwrapped schema should have
+ * either a supported `type` property, a non-empty `type` array containing
+ * supported types, or a non-empty `enum` property containing primitive values.
+ * @param getProperties - A function that extracts the properties/entries/shape
+ * from an object schema. Returns undefined if the schema is not an object.
+ * @param getPropertyRequired - An optional function that extracts whether an
+ * object property is required.
+ * @returns A new Schematizer instance.
+ * @example
+ * This example creates a custom schematizer for a hypothetical validation
+ * library.
+ *
+ * ```js
+ * import {createCustomSchematizer} from 'tinybase/schematizers';
+ *
+ * // Hypothetical library has schemas like:
+ * // {type: 'string'}, {type: 'optional', inner: ...}, etc.
+ *
+ * const unwrapSchema = (
+ *   schema,
+ *   defaultValue,
+ *   allowNull,
+ *   required = true,
+ * ) => {
+ *   if (schema.type === 'optional') {
+ *     return unwrapSchema(schema.inner, defaultValue, allowNull, false);
+ *   }
+ *   if (schema.type === 'nullable') {
+ *     return unwrapSchema(schema.inner, defaultValue, true, required);
+ *   }
+ *   return [
+ *     schema,
+ *     defaultValue ?? schema.default,
+ *     allowNull ?? false,
+ *     required,
+ *   ];
+ * };
+ *
+ * const getProperties = (schema) => schema.fields;
+ *
+ * const schematizer = createCustomSchematizer(unwrapSchema, getProperties);
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: {type: 'object', fields: {name: {type: 'string'}}},
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {name: {type: 'string', required: true}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createCustomSchematizer(
+  unwrapSchema: (
+    schema: any,
+    defaultValue?: any,
+    allowNull?: boolean,
+    required?: boolean,
+  ) => [any, any, boolean] | [any, any, boolean, boolean | undefined],
+  getProperties: (schema: any) => any | undefined,
+  getPropertyRequired?: (
+    schema: any,
+    propertyId: string,
+    propertySchema: any,
+  ) => boolean | undefined,
+): Schematizer;