schema-to-library 0.0.2 → 0.0.4

package/README.md

@@ -6,7 +6,7 @@ npm install -D schema-to-library
 
 ## What is schema-to-library?
 
-**schema-to-library** is a CLI tool that converts JSON Schema into code for validation libraries like Zod,
+**[schema-to-library](https://www.npmjs.com/package/schema-to-library)** is a CLI tool that converts JSON Schema into code for validation libraries like Zod,
 It helps you automatically generate type-safe validation schemas and TypeScript types from your existing schema definitions.
 
 ## Upcoming Support
@@ -24,7 +24,7 @@ Support for additional libraries is planned:
 ```bash
 npx schema-to-zod path/to/input.{json,yaml} -o path/to/output.ts
 ```
-
+-
 ### Example
 
 input:
@@ -75,4 +75,4 @@ export type Schema = z.infer<typeof Schema>
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/schema-to-library?tab=MIT-1-ov-file) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/schema-to-libray?tab=MIT-1-ov-file) for more information.

package/dist/cli/index.d.ts

@@ -0,0 +1,68 @@
+import * as v from 'valibot';
+export declare function cli(fn: (schema: Schema, rootName?: string) => string, helpText: string): Promise<{
+    ok: boolean;
+    value: string;
+    error?: undefined;
+} | {
+    ok: boolean;
+    error: string | undefined;
+    value?: undefined;
+}>;
+export declare function parseYaml(i: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+declare const TypeSchema: v.UnionSchema<[v.LiteralSchema<"string", undefined>, v.LiteralSchema<"number", undefined>, v.LiteralSchema<"integer", undefined>, v.LiteralSchema<"date", undefined>, v.LiteralSchema<"boolean", undefined>, v.LiteralSchema<"array", undefined>, v.LiteralSchema<"object", undefined>, v.LiteralSchema<"null", undefined>], undefined>;
+type Type = v.InferInput<typeof TypeSchema>;
+export declare const FormatSchema: v.UnionSchema<[v.LiteralSchema<"email", undefined>, v.LiteralSchema<"uuid", undefined>, v.LiteralSchema<"uuidv4", undefined>, v.LiteralSchema<"uuidv6", undefined>, v.LiteralSchema<"uuidv7", undefined>, v.LiteralSchema<"uri", undefined>, v.LiteralSchema<"emoji", undefined>, v.LiteralSchema<"base64", undefined>, v.LiteralSchema<"base64url", undefined>, v.LiteralSchema<"nanoid", undefined>, v.LiteralSchema<"cuid", undefined>, v.LiteralSchema<"cuid2", undefined>, v.LiteralSchema<"ulid", undefined>, v.LiteralSchema<"ip", undefined>, v.LiteralSchema<"ipv4", undefined>, v.LiteralSchema<"ipv6", undefined>, v.LiteralSchema<"cidrv4", undefined>, v.LiteralSchema<"cidrv6", undefined>, v.LiteralSchema<"date", undefined>, v.LiteralSchema<"time", undefined>, v.LiteralSchema<"date-time", undefined>, v.LiteralSchema<"duration", undefined>, v.LiteralSchema<"binary", undefined>, v.LiteralSchema<"toLowerCase", undefined>, v.LiteralSchema<"toUpperCase", undefined>, v.LiteralSchema<"trim", undefined>, v.LiteralSchema<"jwt", undefined>, v.LiteralSchema<"int32", undefined>, v.LiteralSchema<"int64", undefined>, v.LiteralSchema<"bigint", undefined>, v.LiteralSchema<"float", undefined>, v.LiteralSchema<"float32", undefined>, v.LiteralSchema<"float64", undefined>, v.LiteralSchema<"double", undefined>, v.LiteralSchema<"decimal", undefined>], undefined>;
+type Format = v.InferInput<typeof FormatSchema>;
+type SchemaType = {
+    title?: string;
+    definitions?: Record<string, SchemaType>;
+    $defs?: Record<string, SchemaType>;
+    name?: string;
+    description?: string;
+    type?: Type | [Type, ...Type[]];
+    format?: Format;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    multipleOf?: number;
+    minItems?: number;
+    maxItems?: number;
+    default?: unknown;
+    example?: unknown;
+    examples?: unknown[];
+    properties?: Record<string, SchemaType>;
+    required?: string[] | boolean;
+    items?: SchemaType;
+    enum?: (string | number | boolean | null | (string | number | boolean | null)[])[];
+    nullable?: boolean;
+    additionalProperties?: SchemaType | boolean;
+    $ref?: string;
+    xml?: {
+        name?: string;
+        wrapped?: boolean;
+    };
+    oneOf?: SchemaType[];
+    allOf?: SchemaType[];
+    anyOf?: SchemaType[];
+    not?: SchemaType;
+    discriminator?: {
+        propertyName?: string;
+    };
+    externalDocs?: {
+        url?: string;
+    };
+    const?: unknown;
+};
+declare const Schema: v.GenericSchema<SchemaType>;
+export type Schema = v.InferInput<typeof Schema>;
+export {};

package/dist/cli/index.js

@@ -0,0 +1,320 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { format } from 'prettier';
+import * as v from 'valibot';
+import { parse } from 'yaml';
+const IOSchema = v.object({
+    input: v.custom((value) => typeof value === 'string' && (value.endsWith('.yaml') || value.endsWith('.json')), 'Input must be a .json, or .yaml file'),
+    output: v.custom((value) => typeof value === 'string' && value.endsWith('.ts'), 'Output must be a .ts file'),
+});
+const IsYAMLSchema = v.custom((value) => typeof value === 'string' && value.endsWith('.yaml'), 'Must end with .yaml');
+const IsJSONSchema = v.custom((value) => typeof value === 'string' && value.endsWith('.json'), 'Must end with .json');
+export async function cli(fn, helpText) {
+    // Slice the arguments to remove the first two (node and script path)
+    const args = process.argv.slice(2);
+    const isHelpRequested = (args) => {
+        return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
+    };
+    if (isHelpRequested(args)) {
+        return {
+            ok: true,
+            value: helpText,
+        };
+    }
+    const i = args[0];
+    const oIdx = args.indexOf('-o');
+    const o = oIdx !== -1 ? args[oIdx + 1] : undefined;
+    const valid = v.safeParse(IOSchema, {
+        input: i,
+        output: o,
+    });
+    if (!valid.success) {
+        return {
+            ok: false,
+            error: valid.issues.map((issue) => issue.message)[0],
+        };
+    }
+    const { input, output } = valid.output;
+    const schemaResult = await parseSchema(input);
+    if (!schemaResult.ok) {
+        return {
+            ok: false,
+            error: schemaResult.error,
+        };
+    }
+    const schemaValid = v.safeParse(Schema, schemaResult.value);
+    if (!schemaValid.success) {
+        return {
+            ok: false,
+            error: schemaValid.issues.map((issue) => issue.message)[0],
+        };
+    }
+    const schema = schemaValid.output;
+    const result = fn(schema);
+    const fmtResult = await fmt(result);
+    if (!fmtResult.ok) {
+        return {
+            ok: false,
+            error: fmtResult.error,
+        };
+    }
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
+    }
+    const writeFileResult = await writeFile(output, fmtResult.value);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
+    }
+    return {
+        ok: true,
+        value: `${output} created`,
+    };
+}
+async function parseSchema(i) {
+    if (i.endsWith('.yaml')) {
+        const valid = v.safeParse(IsYAMLSchema, i);
+        if (!valid.success) {
+            return {
+                ok: false,
+                error: valid.issues.map((issue) => issue.message)[0],
+            };
+        }
+        const input = valid.output;
+        const file = await readFile(input);
+        if (!file.ok) {
+            return {
+                ok: false,
+                error: file.error,
+            };
+        }
+        const yaml = parseYaml(file.value);
+        if (!yaml.ok) {
+            return {
+                ok: false,
+                error: yaml.error,
+            };
+        }
+        return {
+            ok: true,
+            value: yaml.value,
+        };
+    }
+    if (i.endsWith('.json')) {
+        const valid = v.safeParse(IsJSONSchema, i);
+        if (!valid.success) {
+            return {
+                ok: false,
+                error: valid.issues.map((issue) => issue.message)[0],
+            };
+        }
+        const input = valid.output;
+        const file = await readFile(input);
+        if (!file.ok) {
+            return {
+                ok: false,
+                error: file.error,
+            };
+        }
+        return {
+            ok: true,
+            value: JSON.parse(file.value),
+        };
+    }
+    return {
+        ok: false,
+        error: 'Invalid input file type',
+    };
+}
+// parseYaml
+export function parseYaml(i) {
+    try {
+        const yaml = parse(i);
+        return {
+            ok: true,
+            value: yaml,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: String(e),
+        };
+    }
+}
+// readFile
+async function readFile(path) {
+    try {
+        const res = await fsp.readFile(path, 'utf-8');
+        return { ok: true, value: res };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+/**
+ * Formats TypeScript source with Prettier.
+ *
+ * @param code - Source code to format.
+ * @returns A `Result` containing the formatted code or an error message.
+ */
+async function fmt(code) {
+    try {
+        const formatted = await format(code, {
+            parser: 'typescript',
+            printWidth: 100,
+            singleQuote: true,
+            semi: false,
+        });
+        return { ok: true, value: formatted };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+/**
+ * Creates a directory if it does not already exist.
+ *
+ * @param dir - Directory path to create.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+async function mkdir(dir) {
+    try {
+        await fsp.mkdir(dir, { recursive: true });
+        return {
+            ok: true,
+            value: undefined,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+/**
+ * Writes UTF-8 text to a file, creating it if necessary.
+ *
+ * @param path - File path to write.
+ * @param data - Text data to write.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+async function writeFile(path, data) {
+    try {
+        await fsp.writeFile(path, data, 'utf-8');
+        return { ok: true, value: undefined };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+const TypeSchema = v.union([
+    v.literal('string'),
+    v.literal('number'),
+    v.literal('integer'),
+    v.literal('date'),
+    v.literal('boolean'),
+    v.literal('array'),
+    v.literal('object'),
+    v.literal('null'),
+]);
+export const FormatSchema = v.union([
+    v.literal('email'),
+    v.literal('uuid'),
+    v.literal('uuidv4'),
+    v.literal('uuidv6'),
+    v.literal('uuidv7'),
+    v.literal('uri'),
+    v.literal('emoji'),
+    v.literal('base64'),
+    v.literal('base64url'),
+    v.literal('nanoid'),
+    v.literal('cuid'),
+    v.literal('cuid2'),
+    v.literal('ulid'),
+    v.literal('ip'),
+    v.literal('ipv4'),
+    v.literal('ipv6'),
+    v.literal('cidrv4'),
+    v.literal('cidrv6'),
+    v.literal('date'),
+    v.literal('time'),
+    v.literal('date-time'),
+    v.literal('duration'),
+    v.literal('binary'),
+    v.literal('toLowerCase'),
+    v.literal('toUpperCase'),
+    v.literal('trim'),
+    v.literal('jwt'),
+    v.literal('int32'),
+    v.literal('int64'),
+    v.literal('bigint'),
+    v.literal('float'),
+    v.literal('float32'),
+    v.literal('float64'),
+    v.literal('double'),
+    v.literal('decimal'),
+]);
+const Schema = v.looseObject({
+    title: v.optional(v.string()),
+    definitions: v.optional(v.record(v.string(), v.lazy(() => Schema))),
+    $defs: v.optional(v.record(v.string(), v.lazy(() => Schema))),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    type: v.optional(v.union([TypeSchema, v.tuple([TypeSchema])])),
+    format: v.optional(FormatSchema),
+    pattern: v.optional(v.string()),
+    minLength: v.optional(v.number()),
+    maxLength: v.optional(v.number()),
+    minimum: v.optional(v.number()),
+    maximum: v.optional(v.number()),
+    exclusiveMinimum: v.optional(v.union([v.number(), v.boolean()])),
+    exclusiveMaximum: v.optional(v.union([v.number(), v.boolean()])),
+    multipleOf: v.optional(v.number()),
+    minItems: v.optional(v.number()),
+    maxItems: v.optional(v.number()),
+    default: v.optional(v.unknown()),
+    example: v.optional(v.unknown()),
+    examples: v.optional(v.array(v.unknown())),
+    properties: v.optional(v.record(v.string(), v.lazy(() => Schema))),
+    required: v.optional(v.union([v.array(v.string()), v.boolean()])),
+    items: v.optional(v.lazy(() => Schema)),
+    enum: v.optional(v.array(v.union([
+        v.string(),
+        v.number(),
+        v.boolean(),
+        v.null(),
+        v.array(v.union([v.string(), v.number(), v.boolean(), v.null()])),
+    ]))),
+    nullable: v.optional(v.boolean()),
+    additionalProperties: v.optional(v.union([v.lazy(() => Schema), v.boolean()])),
+    $ref: v.optional(v.string()),
+    xml: v.optional(v.object({
+        name: v.optional(v.string()),
+        wrapped: v.optional(v.boolean()),
+    })),
+    oneOf: v.optional(v.array(v.lazy(() => Schema))),
+    allOf: v.optional(v.array(v.lazy(() => Schema))),
+    anyOf: v.optional(v.array(v.lazy(() => Schema))),
+    not: v.optional(v.lazy(() => Schema)),
+    discriminator: v.optional(v.object({
+        propertyName: v.optional(v.string()),
+    })),
+    externalDocs: v.optional(v.object({
+        url: v.optional(v.string()),
+    })),
+    const: v.optional(v.unknown()),
+});

package/dist/helper/dep/resolve-schema-dependencies-from-shema.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../cli/index.js';
+export declare function resolveSchemaDependenciesFromSchema(schema: Schema): string[];

package/dist/helper/dep/resolve-schema-dependencies-from-shema.js

@@ -0,0 +1,89 @@
+export function resolveSchemaDependenciesFromSchema(schema) {
+    // Merge both definitions and $defs
+    const definitions = {
+        ...(schema.definitions ?? {}),
+        ...(schema.$defs ?? {}),
+    };
+    const isRecord = (v) => typeof v === 'object' && v !== null;
+    const collectRefs = (schema) => {
+        const refs = new Set();
+        const stack = [schema];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!isRecord(node))
+                continue;
+            if ('$ref' in node && typeof node.$ref === 'string') {
+                const ref = node.$ref;
+                if (ref === '#')
+                    continue;
+                // Check for both definitions and $defs refs
+                const match = ref.match(/^#\/(?:definitions|\$defs)\/([^/]+)$/);
+                if (match) {
+                    refs.add(match[1]);
+                }
+                // Check for relative references like #node
+                const relativeMatch = ref.match(/^#([^/]+)$/);
+                if (relativeMatch) {
+                    refs.add(relativeMatch[1]);
+                }
+                // Check for external file references with fragments
+                if (ref.includes('#')) {
+                    const [filePath, fragment] = ref.split('#');
+                    if (fragment) {
+                        // Extract the schema name from the fragment
+                        const fragmentMatch = fragment.match(/^\/(?:definitions|\$defs)\/([^/]+)$/);
+                        if (fragmentMatch) {
+                            refs.add(fragmentMatch[1]);
+                        }
+                        // Handle simple fragment like "#node"
+                        const simpleMatch = fragment.match(/^\/([^/]+)$/);
+                        if (simpleMatch) {
+                            refs.add(simpleMatch[1]);
+                        }
+                    }
+                    // Skip external references that we can't resolve
+                    continue;
+                }
+            }
+            for (const value of Object.values(node)) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (isRecord(item))
+                            stack.push(item);
+                    }
+                }
+                else if (isRecord(value)) {
+                    stack.push(value);
+                }
+            }
+        }
+        return Array.from(refs).sort();
+    };
+    const sorted = [];
+    const perm = new Set();
+    const temp = new Set();
+    const visit = (name) => {
+        if (perm.has(name))
+            return;
+        if (temp.has(name)) {
+            // Circular dependency detected - skip this dependency but continue processing
+            // console.warn(`Warning: Circular dependency detected for type "${name}", skipping...`)
+            return;
+        }
+        const schema = definitions[name];
+        if (!schema)
+            return;
+        temp.add(name);
+        for (const ref of collectRefs(schema)) {
+            if (ref in definitions)
+                visit(ref);
+        }
+        temp.delete(name);
+        perm.add(name);
+        sorted.push(name);
+    };
+    for (const name of Object.keys(definitions).sort()) {
+        visit(name);
+    }
+    return sorted;
+}

package/dist/helper/dep/type.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../cli/index.js';
+export declare function type(schema: Schema, rootName?: string): string;

package/dist/helper/dep/type.js

@@ -0,0 +1,156 @@
+import { normalizeTypes, toPascalCase } from '../utils/index.js';
+export function type(schema, rootName = 'Schema') {
+    if (schema === undefined)
+        return '';
+    // $ref case
+    if (schema.$ref) {
+        if (schema.$ref === '#' || schema.$ref === '') {
+            return `z.infer<typeof ${rootName}>`;
+        }
+        const TABLE = [
+            ['#/components/schemas/', 'Schema'],
+            ['#/definitions/', 'Schema'],
+            ['#/$defs/', 'Schema'],
+        ];
+        for (const [prefix] of TABLE) {
+            if (schema.$ref?.startsWith(prefix)) {
+                const name = schema.$ref.slice(prefix.length);
+                const pascalCaseName = toPascalCase(name);
+                // For self-references, use the type name directly
+                if (pascalCaseName === rootName) {
+                    return `${pascalCaseName}Type`;
+                }
+                // For other references, use the type name directly to avoid circular references
+                return `${pascalCaseName}Type`;
+            }
+        }
+        // Handle relative references like #animal
+        if (schema.$ref?.startsWith('#')) {
+            const refName = schema.$ref.slice(1); // Remove the leading #
+            if (refName === '') {
+                return `z.infer<typeof ${rootName}>`;
+            }
+            // Only handle simple references like #animal, not complex paths
+            if (!refName.includes('/')) {
+                const pascalCaseName = toPascalCase(refName);
+                return `${pascalCaseName}Type`;
+            }
+        }
+        // Handle external file references with fragments
+        if (schema.$ref?.includes('#')) {
+            const [filePath, fragment] = schema.$ref.split('#');
+            // All external references are unknown
+            return 'unknown';
+        }
+        // Handle HTTP references without fragments
+        if (schema.$ref?.startsWith('http')) {
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+    // combinators
+    if (schema.oneOf)
+        return union(schema.oneOf, rootName);
+    if (schema.anyOf)
+        return union(schema.anyOf, rootName);
+    if (schema.allOf)
+        return intersection(schema.allOf, rootName);
+    if (schema.not)
+        return 'unknown';
+    // const
+    if (schema.const !== undefined) {
+        return typeof schema.const === 'string' ? `"${schema.const}"` : String(schema.const);
+    }
+    // enum
+    if (schema.enum) {
+        if (schema.enum.length === 1) {
+            const v = schema.enum[0];
+            return typeof v === 'string' ? `"${v}"` : String(v);
+        }
+        const allStrings = schema.enum.every((v) => typeof v === 'string');
+        if (allStrings) {
+            return `(${schema.enum.map((v) => `"${v}"`).join(' | ')})`;
+        }
+        return `(${schema.enum.map((v) => (typeof v === 'string' ? `"${v}"` : String(v))).join(' | ')})`;
+    }
+    // properties
+    if (schema.properties)
+        return object(schema, rootName);
+    const t = normalizeTypes(schema.type);
+    // primitive types
+    if (t.includes('string'))
+        return 'string';
+    if (t.includes('number'))
+        return 'number';
+    if (t.includes('integer'))
+        return 'number';
+    if (t.includes('boolean'))
+        return 'boolean';
+    if (t.includes('array'))
+        return array(schema, rootName);
+    if (t.includes('object'))
+        return object(schema, rootName);
+    if (t.includes('date'))
+        return 'Date';
+    if (t.length === 1 && t[0] === 'null')
+        return 'null';
+    return 'unknown';
+}
+function union(schemas, rootName) {
+    const types = schemas.map((s) => type(s, rootName));
+    return `(${types.join(' | ')})`;
+}
+function intersection(schemas, rootName) {
+    const types = schemas
+        .filter((s) => {
+        // null type is excluded
+        if (s.type === 'null')
+            return false;
+        // nullable: true only is excluded
+        if (s.nullable === true && Object.keys(s).length === 1)
+            return false;
+        // simple properties (default, const, etc.) are excluded
+        if (Object.keys(s).length === 1 && (s.default !== undefined || s.const !== undefined))
+            return false;
+        return true;
+    })
+        .map((s) => type(s, rootName));
+    if (types.length === 0)
+        return 'unknown';
+    if (types.length === 1)
+        return types[0];
+    return `(${types.join(' & ')})`;
+}
+function array(schema, rootName) {
+    if (schema.items) {
+        const itemType = type(schema.items, rootName);
+        return `${itemType}[]`;
+    }
+    return 'unknown[]';
+}
+function object(schema, rootName) {
+    if (!schema.properties) {
+        if (schema.additionalProperties) {
+            if (typeof schema.additionalProperties === 'boolean') {
+                return schema.additionalProperties ? 'Record<string, unknown>' : 'Record<string, never>';
+            }
+            const valueType = type(schema.additionalProperties, rootName);
+            return `Record<string, ${valueType}>`;
+        }
+        return 'Record<string, unknown>';
+    }
+    const properties = [];
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        const propType = type(propSchema, rootName);
+        const isRequired = required.includes(key);
+        const safeKey = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `"${key}"`;
+        if (isRequired) {
+            properties.push(`${safeKey}: ${propType}`);
+        }
+        else {
+            properties.push(`${safeKey}?: ${propType}`);
+        }
+    }
+    return `{${properties.join('; ')}}`;
+}

package/dist/helper/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveSchemaDependenciesFromSchema } from './dep/resolve-schema-dependencies-from-shema.js';
+export { type } from './dep/type.js';
+export { normalizeTypes, toPascalCase } from './utils/index.js';

package/dist/helper/index.js

@@ -0,0 +1,3 @@
+export { resolveSchemaDependenciesFromSchema } from './dep/resolve-schema-dependencies-from-shema.js';
+export { type } from './dep/type.js';
+export { normalizeTypes, toPascalCase } from './utils/index.js';

package/dist/helper/utils/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param name
+ * @returns
+ */
+export declare function toPascalCase(name: string): string;
+/**
+ *
+ * @param t
+ * @returns
+ */
+export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null' | [
+    'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null',
+    ...('string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null')[]
+]): ("string" | "number" | "boolean" | "object" | "integer" | "date" | "array" | "null")[];