@oscarpalmer/jhunal 0.3.0 → 0.4.0

package/src/schematic.ts

@@ -1,5 +1,13 @@
 import type {Inferred, Schema, Schematic, Typed, TypedSchema} from './model';
-import {getValidatedSchema, validate} from './validation';
+import {validateSchema} from './validation/schema.validation';
+import {validateValue} from './validation/value.validation';
+
+/**
+ * Create a schematic from a schema
+ */
+export function schematic<Model extends Schema>(
+	schema: Model,
+): Schematic<Inferred<Model>>;
 
 /**
  * Create a schematic from a typed schema
@@ -8,19 +16,15 @@ export function schematic<Model extends Typed>(
 	schema: TypedSchema<Model>,
 ): Schematic<Model>;
 
-/**
- * Create a schematic from a schema
- */
 export function schematic<Model extends Schema>(
 	schema: Model,
-): Schematic<Inferred<Model>>;
-
-export function schematic<Model extends Schema>(schema: Model) {
-	const validated = getValidatedSchema(schema);
+): Schematic<Model> {
+	const validated = validateSchema(schema);
 
 	const canValidate = validated.length > 0;
 
 	return Object.freeze({
-		is: (value: unknown) => canValidate && validate(validated, value),
-	});
+		$schematic: true,
+		is: (value: unknown) => canValidate && validateValue(validated, value),
+	}) as never;
 }

package/src/validation/schema.validation.ts

@@ -0,0 +1,63 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {getTypes} from '../helpers';
+import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../model';
+
+export function validateSchema(schema: unknown): ValidatedSchema {
+	if (validatedSchemas.has(schema as never)) {
+		return validatedSchemas.get(schema as never) as ValidatedSchema;
+	}
+
+	const validated: ValidatedSchema = {
+		keys: [],
+		length: 0,
+		properties: {},
+	};
+
+	if (typeof schema !== 'object' || schema === null) {
+		return validated;
+	}
+
+	const keys = Object.keys(schema);
+	const {length} = keys;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const value = (schema as Schema)[key];
+
+		let required = true;
+		let types: ValidatedPropertyType[];
+
+		if (Array.isArray(value)) {
+			types = getTypes(value);
+		} else if (typeof value === 'object' && value !== null) {
+			if (typeof (value as PlainObject).required === 'boolean') {
+				required = (value as PlainObject).required as boolean;
+			}
+
+			types = getTypes((value as PlainObject).type);
+		} else {
+			types = getTypes(value);
+		}
+
+		if (types.length > 0) {
+			if (!required && !types.includes('undefined')) {
+				types.push('undefined');
+			}
+
+			validated.keys.push(key);
+
+			validated.properties[key] = {
+				required,
+				types,
+			};
+
+			validated.length += 1;
+		}
+	}
+
+	validatedSchemas.set(schema as never, validated);
+
+	return validated;
+}
+
+export const validatedSchemas = new WeakMap<Schema, ValidatedSchema>();

package/src/validation/type.validation.ts

@@ -0,0 +1,34 @@
+import {isDateLike, isSchematic} from '../is';
+import type {ValidatedPropertyType, ValidatedSchema, Values} from '../model';
+import {validateValue} from './value.validation';
+
+export function validateType(
+	type: ValidatedPropertyType,
+	value: unknown,
+): boolean {
+	if (typeof type === 'string') {
+		return validators[type](value);
+	}
+
+	if (isSchematic(type)) {
+		return type.is(value);
+	}
+
+	return validateValue(type as ValidatedSchema, value);
+}
+
+const validators: Record<keyof Values, (value: unknown) => boolean> = {
+	array: Array.isArray,
+	bigint: value => typeof value === 'bigint',
+	boolean: value => typeof value === 'boolean',
+	date: value => value instanceof Date,
+	'date-like': isDateLike,
+	function: value => typeof value === 'function',
+	null: value => value === null,
+	number: value => typeof value === 'number',
+	numerical: value => validators.bigint(value) || validators.number(value),
+	object: value => typeof value === 'object' && value !== null,
+	string: value => typeof value === 'string',
+	symbol: value => typeof value === 'symbol',
+	undefined: value => value === undefined,
+};

package/src/validation/value.validation.ts

@@ -0,0 +1,46 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {ValidatedSchema} from '../model';
+import {validateType} from './type.validation';
+
+export function validateValue(
+	validated: ValidatedSchema,
+	obj: unknown,
+): boolean {
+	if (typeof obj !== 'object' || obj === null) {
+		return false;
+	}
+
+	outer: for (let keyIndex = 0; keyIndex < validated.length; keyIndex += 1) {
+		const key = validated.keys[keyIndex];
+		const property = validated.properties[key];
+		const value = (obj as PlainObject)[key];
+
+		if (
+			value === undefined &&
+			property.required &&
+			!property.types.includes('undefined')
+		) {
+			return false;
+		}
+
+		const typesLength = property.types.length;
+
+		if (typesLength === 1) {
+			if (!validateType(property.types[0], value)) {
+				return false;
+			}
+
+			continue;
+		}
+
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			if (validateType(property.types[typeIndex], value)) {
+				continue outer;
+			}
+		}
+
+		return false;
+	}
+
+	return true;
+}

package/types/helpers.d.cts

@@ -1,18 +1,43 @@
 // Generated by dts-bundle-generator v9.5.1
 
+/**
+ * A schematic for validating objects
+ */
+export type Schematic<Model> = {
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model;
+};
+export type ValidatedProperty = {
+	required: boolean;
+	types: ValidatedPropertyType[];
+};
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
+export type ValidatedSchema = {
+	keys: string[];
+	length: number;
+	properties: ValidatedSchemaProperties;
+};
+export type ValidatedSchemaProperties = {
+	[key: string]: ValidatedProperty;
+};
+export type ValueKey = keyof Values;
 export type Values = {
 	array: unknown[];
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
+	"date-like": number | string | Date;
 	function: Function;
 	null: null;
 	number: number;
+	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;
 	undefined: undefined;
 };
-export declare function getTypes(value: unknown): (keyof Values)[];
+export declare function getTypes(value: unknown): ValidatedPropertyType[];
 
 export {};

package/types/helpers.d.ts

@@ -1,2 +1,2 @@
-import type { Values } from './model';
-export declare function getTypes(value: unknown): (keyof Values)[];
+import type { ValidatedPropertyType } from './model';
+export declare function getTypes(value: unknown): ValidatedPropertyType[];

package/types/index.d.cts

@@ -270,20 +270,25 @@ export type UnionToTuple<T, L = LastOfUnion<T>> = IsNever<T> extends false ? [
 	L
 ] : [
 ];
+export type AutoInferExclude = "date-like" | "numerical";
 export type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
+	[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
+	[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+}[AutoInferExclude] : SpecificKey : never;
 export type GetTypes<Value extends unknown[]> = Value extends [
-	infer Single
-] ? Single : Value;
+	infer Type
+] ? Type : Value;
 export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? Value["type"] extends keyof Values ? Values[Value["type"]] : Value["type"] extends (keyof Values)[] ? Values[Value["type"][number]] : never : never;
-export type InferValue<Value> = Value extends keyof Values ? Values[Value] : Value extends (keyof Values)[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = {
+export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value["type"]> : never;
+export type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
+export type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
+export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
+export type Inferred<Model extends Schema> = Simplify<{
 	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
 } & {
 	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
-};
+}>;
 export type InferredOptionalProperties<Model extends Schema> = {
 	[Key in keyof Model]: Model[Key] extends Property ? Model[Key]["required"] extends false ? Key : never : never;
 }[keyof Model];
@@ -296,8 +301,9 @@ export type OptionalProperty<Type> = {
 };
 export type Property = {
 	required?: boolean;
-	type: keyof Values | (keyof Values)[];
+	type: PropertyType | PropertyType[];
 };
+export type PropertyType = Schema | Schematic<unknown> | ValueKey;
 export type RequiredProperty<Type> = {
 	required: true;
 	type: GetType<Type>;
@@ -305,7 +311,9 @@ export type RequiredProperty<Type> = {
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
+};
 /**
  * A schematic for validating objects
  */
@@ -324,26 +332,29 @@ export type TypedSchema<Model extends Typed> = Simplify<{
 } & {
 	[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
 }>;
+export type ValueKey = keyof Values;
 export type Values = {
 	array: unknown[];
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
+	"date-like": number | string | Date;
 	function: Function;
 	null: null;
 	number: number;
+	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;
 	undefined: undefined;
 };
-/**
- * Create a schematic from a typed schema
- */
-export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 /**
  * Create a schematic from a schema
  */
 export declare function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
+/**
+ * Create a schematic from a typed schema
+ */
+export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 
 export {};

package/types/index.d.ts

@@ -1,2 +1,2 @@
-export type { Schema, Schematic } from './model';
+export type { Schema, Schematic, TypedSchema } from './model';
 export * from './schematic';

package/types/is.d.cts

@@ -0,0 +1,15 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A schematic for validating objects
+ */
+export type Schematic<Model> = {
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model;
+};
+export declare function isDateLike(value: unknown): value is Date;
+export declare function isSchematic(value: unknown): value is Schematic<never>;
+
+export {};

package/types/is.d.ts

@@ -0,0 +1,3 @@
+import type { Schematic } from './model';
+export declare function isDateLike(value: unknown): value is Date;
+export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/model.d.cts

@@ -270,20 +270,25 @@ export type UnionToTuple<T, L = LastOfUnion<T>> = IsNever<T> extends false ? [
 	L
 ] : [
 ];
+export type AutoInferExclude = "date-like" | "numerical";
 export type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
+	[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
+	[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+}[AutoInferExclude] : SpecificKey : never;
 export type GetTypes<Value extends unknown[]> = Value extends [
-	infer Single
-] ? Single : Value;
+	infer Type
+] ? Type : Value;
 export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? Value["type"] extends keyof Values ? Values[Value["type"]] : Value["type"] extends (keyof Values)[] ? Values[Value["type"][number]] : never : never;
-export type InferValue<Value> = Value extends keyof Values ? Values[Value] : Value extends (keyof Values)[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = {
+export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value["type"]> : never;
+export type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
+export type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
+export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
+export type Inferred<Model extends Schema> = Simplify<{
 	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
 } & {
 	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
-};
+}>;
 export type InferredOptionalProperties<Model extends Schema> = {
 	[Key in keyof Model]: Model[Key] extends Property ? Model[Key]["required"] extends false ? Key : never : never;
 }[keyof Model];
@@ -296,8 +301,9 @@ export type OptionalProperty<Type> = {
 };
 export type Property = {
 	required?: boolean;
-	type: keyof Values | (keyof Values)[];
+	type: PropertyType | PropertyType[];
 };
+export type PropertyType = Schema | Schematic<unknown> | ValueKey;
 export type RequiredProperty<Type> = {
 	required: true;
 	type: GetType<Type>;
@@ -305,7 +311,9 @@ export type RequiredProperty<Type> = {
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
+};
 /**
  * A schematic for validating objects
  */
@@ -326,21 +334,28 @@ export type TypedSchema<Model extends Typed> = Simplify<{
 }>;
 export type ValidatedProperty = {
 	required: boolean;
-	types: (keyof Values)[];
+	types: ValidatedPropertyType[];
 };
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
 export type ValidatedSchema = {
 	keys: string[];
 	length: number;
-	properties: Record<string, ValidatedProperty>;
+	properties: ValidatedSchemaProperties;
+};
+export type ValidatedSchemaProperties = {
+	[key: string]: ValidatedProperty;
 };
+export type ValueKey = keyof Values;
 export type Values = {
 	array: unknown[];
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
+	"date-like": number | string | Date;
 	function: Function;
 	null: null;
 	number: number;
+	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;

package/types/model.d.ts

@@ -1,16 +1,21 @@
 import type { OptionalKeysOf, RequiredKeysOf, Simplify, UnionToTuple } from 'type-fest';
+export type AutoInferExclude = 'date-like' | 'numerical';
 export type GetKey<Value> = {
-    [Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
-export type GetTypes<Value extends unknown[]> = Value extends [infer Single] ? Single : Value;
+    [Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
+    [Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+}[AutoInferExclude] : SpecificKey : never;
+export type GetTypes<Value extends unknown[]> = Value extends [infer Type] ? Type : Value;
 export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? Value['type'] extends keyof Values ? Values[Value['type']] : Value['type'] extends (keyof Values)[] ? Values[Value['type'][number]] : never : never;
-export type InferValue<Value> = Value extends keyof Values ? Values[Value] : Value extends (keyof Values)[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = {
+export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value['type']> : never;
+type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
+type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
+export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
+export type Inferred<Model extends Schema> = Simplify<{
     [Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
 } & {
     [Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
-};
+}>;
 export type InferredOptionalProperties<Model extends Schema> = {
     [Key in keyof Model]: Model[Key] extends Property ? Model[Key]['required'] extends false ? Key : never : never;
 }[keyof Model];
@@ -23,8 +28,9 @@ export type OptionalProperty<Type> = {
 };
 export type Property = {
     required?: boolean;
-    type: keyof Values | (keyof Values)[];
+    type: PropertyType | PropertyType[];
 };
+type PropertyType = Schema | Schematic<unknown> | ValueKey;
 export type RequiredProperty<Type> = {
     required: true;
     type: GetType<Type>;
@@ -32,7 +38,9 @@ export type RequiredProperty<Type> = {
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
+export type Schema = {
+    [key: string]: Property | ValueKey | ValueKey[];
+};
 /**
  * A schematic for validating objects
  */
@@ -53,23 +61,31 @@ export type TypedSchema<Model extends Typed> = Simplify<{
 }>;
 export type ValidatedProperty = {
     required: boolean;
-    types: (keyof Values)[];
+    types: ValidatedPropertyType[];
 };
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
 export type ValidatedSchema = {
     keys: string[];
     length: number;
-    properties: Record<string, ValidatedProperty>;
+    properties: ValidatedSchemaProperties;
+};
+type ValidatedSchemaProperties = {
+    [key: string]: ValidatedProperty;
 };
+export type ValueKey = keyof Values;
 export type Values = {
     array: unknown[];
     bigint: bigint;
     boolean: boolean;
     date: Date;
+    'date-like': number | string | Date;
     function: Function;
     null: null;
     number: number;
+    numerical: bigint | number;
     object: object;
     string: string;
     symbol: symbol;
     undefined: undefined;
 };
+export {};

package/types/schematic.d.cts

@@ -270,20 +270,25 @@ export type UnionToTuple<T, L = LastOfUnion<T>> = IsNever<T> extends false ? [
 	L
 ] : [
 ];
+export type AutoInferExclude = "date-like" | "numerical";
 export type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
+	[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
+	[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+}[AutoInferExclude] : SpecificKey : never;
 export type GetTypes<Value extends unknown[]> = Value extends [
-	infer Single
-] ? Single : Value;
+	infer Type
+] ? Type : Value;
 export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? Value["type"] extends keyof Values ? Values[Value["type"]] : Value["type"] extends (keyof Values)[] ? Values[Value["type"][number]] : never : never;
-export type InferValue<Value> = Value extends keyof Values ? Values[Value] : Value extends (keyof Values)[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = {
+export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value["type"]> : never;
+export type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
+export type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
+export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
+export type Inferred<Model extends Schema> = Simplify<{
 	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
 } & {
 	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
-};
+}>;
 export type InferredOptionalProperties<Model extends Schema> = {
 	[Key in keyof Model]: Model[Key] extends Property ? Model[Key]["required"] extends false ? Key : never : never;
 }[keyof Model];
@@ -296,8 +301,9 @@ export type OptionalProperty<Type> = {
 };
 export type Property = {
 	required?: boolean;
-	type: keyof Values | (keyof Values)[];
+	type: PropertyType | PropertyType[];
 };
+export type PropertyType = Schema | Schematic<unknown> | ValueKey;
 export type RequiredProperty<Type> = {
 	required: true;
 	type: GetType<Type>;
@@ -305,7 +311,9 @@ export type RequiredProperty<Type> = {
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
+};
 /**
  * A schematic for validating objects
  */
@@ -324,26 +332,29 @@ export type TypedSchema<Model extends Typed> = Simplify<{
 } & {
 	[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
 }>;
+export type ValueKey = keyof Values;
 export type Values = {
 	array: unknown[];
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
+	"date-like": number | string | Date;
 	function: Function;
 	null: null;
 	number: number;
+	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;
 	undefined: undefined;
 };
-/**
- * Create a schematic from a typed schema
- */
-export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 /**
  * Create a schematic from a schema
  */
 export declare function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
+/**
+ * Create a schematic from a typed schema
+ */
+export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 
 export {};

package/types/schematic.d.ts

@@ -1,9 +1,9 @@
 import type { Inferred, Schema, Schematic, Typed, TypedSchema } from './model';
-/**
- * Create a schematic from a typed schema
- */
-export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 /**
  * Create a schematic from a schema
  */
 export declare function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
+/**
+ * Create a schematic from a typed schema
+ */
+export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;