@sinclair/typebox 0.32.3 → 0.32.5

package/build/import/errors/index.d.mts

@@ -1,2 +1,2 @@
 export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors.mjs';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction } from './function.mjs';
+export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function.mjs';

package/build/import/value/clean/clean.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;

package/build/import/value/convert/convert.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;

package/build/import/value/default/default.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;

package/build/import/value/value/value.d.mts

@@ -16,13 +16,13 @@ export declare function Check<T extends TSchema>(schema: T, references: TSchema[
 /** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
 /** Decodes a value or throws if error */
@@ -30,9 +30,9 @@ export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T
 /** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */

package/build/require/errors/index.d.ts

@@ -1,2 +1,2 @@
 export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction } from './function';
+export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function';

package/build/require/value/clean/clean.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index';
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;

package/build/require/value/convert/convert.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index';
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;

package/build/require/value/default/default.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index';
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;

package/build/require/value/value/value.d.ts

@@ -16,13 +16,13 @@ export declare function Check<T extends TSchema>(schema: T, references: TSchema[
 /** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
 /** Decodes a value or throws if error */
@@ -30,9 +30,9 @@ export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T
 /** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */

package/license

@@ -4,7 +4,7 @@ Json Schema Type Builder with Static Type Resolution for TypeScript
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.3",
+  "version": "0.32.5",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",