typebox 1.0.35 → 1.0.37

package/build/schema/build.d.mts

@@ -1,5 +1,5 @@
 import * as Engine from './engine/index.mjs';
-import { type XSchemaLike } from './types/index.mjs';
+import { type XSchema } from './types/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
 export interface EvaluateResult {
     IsEvaluated: boolean;
@@ -13,11 +13,11 @@ export declare class BuildResult {
     private readonly functions;
     private readonly call;
     private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    constructor(context: Record<PropertyKey, XSchema>, schema: XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
     /** Returns the Context used for this build */
-    Context(): Record<PropertyKey, XSchemaLike>;
+    Context(): Record<PropertyKey, XSchema>;
     /** Returns the Schema used for this build */
-    Schema(): XSchemaLike;
+    Schema(): XSchema;
     /** Returns true if this build requires a Unevaluated context */
     UseUnevaluated(): boolean;
     /** Returns external variables */
@@ -30,6 +30,6 @@ export declare class BuildResult {
     Evaluate(): EvaluateResult;
 }
 /** Builds a schema into a optimized runtime validator */
-export declare function Build(schema: XSchemaLike): BuildResult;
+export declare function Build(schema: XSchema): BuildResult;
 /** Builds a schema into a optimized runtime validator */
-export declare function Build(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike): BuildResult;
+export declare function Build(context: Record<PropertyKey, XSchema>, schema: XSchema): BuildResult;

package/build/schema/check.d.mts

@@ -1,5 +1,5 @@
-import { XSchemaLike } from './types/index.mjs';
+import { XSchema } from './types/index.mjs';
 /** Checks a value against the provided schema */
-export declare function Check(schema: XSchemaLike, value: unknown): boolean;
+export declare function Check(schema: XSchema, value: unknown): boolean;
 /** Checks a value against the provided schema */
-export declare function Check(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): boolean;
+export declare function Check(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): boolean;

package/build/schema/deref/deref.d.mts

@@ -1,4 +1,4 @@
 import * as S from '../types/index.mjs';
-export declare function Rebase(baseUri: string, schema: S.XSchema): string;
+export declare function Rebase(baseUri: string, schema: S.XSchemaObject): string;
 /** Deferences a schema with the given Ref */
 export declare function Deref(schema: object, ref: S.XRef): unknown | undefined;

package/build/schema/deref/deref.mjs

@@ -35,7 +35,7 @@ function Select(schema, baseUri, $ref) {
     }
     if (IsHashPointer($ref)) {
         const target = Pointer.Get(schema, $ref.slice(1));
-        if (S.IsSchemaLike(target))
+        if (S.IsSchema(target))
             return target;
     }
     return undefined;
@@ -55,7 +55,7 @@ function FromObject(schema, baseUrl, ref) {
     // ----------------------------------------------------------------
     const rebase = Rebase(baseUrl, schema);
     const target = Select(schema, rebase, ref.$ref);
-    if (S.IsSchemaLike(target))
+    if (S.IsSchema(target))
         return target;
     // Keep searching ...
     return Object.values(schema).reduce((result, subschema) => result || FromValue(subschema, rebase, ref), undefined);

package/build/schema/engine/_context.d.mts

@@ -2,15 +2,15 @@ import * as S from '../types/index.mjs';
 import type { TValidationError } from '../../error/index.mjs';
 export declare function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean;
 export declare class BaseContext {
-    protected readonly context: Record<PropertyKey, S.XSchemaLike>;
-    protected readonly schema: S.XSchemaLike;
-    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike);
+    protected readonly context: Record<PropertyKey, S.XSchema>;
+    protected readonly schema: S.XSchema;
+    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
     GetContext(): Record<PropertyKey, object | boolean>;
     GetSchema(): object | boolean;
 }
 export declare class BuildContext extends BaseContext {
     private readonly hasUnevaluated;
-    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike, hasUnevaluated: boolean);
+    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, hasUnevaluated: boolean);
     UseUnevaluated(): boolean;
     AddIndex(index: string): string;
     AddKey(key: string): string;
@@ -20,7 +20,7 @@ export declare class BuildContext extends BaseContext {
 export declare class CheckContext extends BaseContext {
     private readonly indices;
     private readonly keys;
-    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike);
+    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
     AddIndex(index: number): true;
     AddKey(key: string): true;
     GetIndices(): Set<number>;
@@ -31,12 +31,12 @@ export declare class CheckContext extends BaseContext {
 export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
     private readonly callback;
-    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike, callback: ErrorContextCallback);
+    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, callback: ErrorContextCallback);
     AddError(error: TValidationError): false;
 }
 export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
-    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike);
+    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
     AddError(error: TValidationError): false;
     GetErrors(): TValidationError[];
 }

package/build/schema/engine/_functions.d.mts

@@ -2,4 +2,4 @@ import * as S from '../types/index.mjs';
 import { BuildContext } from './_context.mjs';
 export declare function ResetFunctions(): void;
 export declare function GetFunctions(): string[];
-export declare function CreateFunction(context: BuildContext, schema: S.XSchemaLike, value: string): string;
+export declare function CreateFunction(context: BuildContext, schema: S.XSchema, value: string): string;

package/build/schema/engine/_reducer.d.mts

@@ -1,3 +1,3 @@
 import * as S from '../types/index.mjs';
 import { BuildContext } from './_context.mjs';
-export declare function Reducer(context: BuildContext, schemas: S.XSchemaLike[], value: string, check: string): string;
+export declare function Reducer(context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;

package/build/schema/engine/ref.mjs

@@ -18,7 +18,7 @@ function Resolve(context, schema) {
     }
     // inline referential schema
     const dereferenced = Deref(schemaRoot, { $ref: schema.$ref });
-    return S.IsSchemaLike(dereferenced) ? dereferenced : false;
+    return S.IsSchema(dereferenced) ? dereferenced : false;
 }
 // ------------------------------------------------------------------
 // Build
@@ -32,12 +32,12 @@ export function BuildRef(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckRef(context, schema, value) {
     const target = Resolve(context, schema);
-    return (S.IsSchemaLike(target) && CheckSchema(context, target, value));
+    return (S.IsSchema(target) && CheckSchema(context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRef(context, schemaPath, instancePath, schema, value) {
     const target = Resolve(context, schema);
-    return (S.IsSchemaLike(target) && ErrorSchema(context, '#', instancePath, target, value));
+    return (S.IsSchema(target) && ErrorSchema(context, '#', instancePath, target, value));
 }

package/build/schema/engine/schema.d.mts

@@ -1,5 +1,5 @@
 import * as S from '../types/index.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchema(context: BuildContext, schema: S.XSchemaLike, value: string): string;
-export declare function CheckSchema(context: CheckContext, schema: S.XSchemaLike, value: unknown): boolean;
-export declare function ErrorSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XSchemaLike, value: unknown): boolean;
+export declare function BuildSchema(context: BuildContext, schema: S.XSchema, value: string): string;
+export declare function CheckSchema(context: CheckContext, schema: S.XSchema, value: unknown): boolean;
+export declare function ErrorSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XSchema, value: unknown): boolean;

package/build/schema/engine/schema.mjs

@@ -58,7 +58,7 @@ function HasObjectType(schema) {
     return HasTypeName(schema, 'object');
 }
 function HasObjectKeywords(schema) {
-    return S.IsSchema(schema) && (S.IsAdditionalProperties(schema) ||
+    return S.IsSchemaObject(schema) && (S.IsAdditionalProperties(schema) ||
         S.IsDependencies(schema) ||
         S.IsDependentRequired(schema) ||
         S.IsDependentSchemas(schema) ||
@@ -77,7 +77,7 @@ function HasArrayType(schema) {
     return HasTypeName(schema, 'array');
 }
 function HasArrayKeywords(schema) {
-    return S.IsSchema(schema) && (S.IsAdditionalItems(schema) ||
+    return S.IsSchemaObject(schema) && (S.IsAdditionalItems(schema) ||
         S.IsItems(schema) ||
         S.IsContains(schema) ||
         S.IsMaxContains(schema) ||
@@ -95,7 +95,7 @@ function HasStringType(schema) {
     return HasTypeName(schema, 'string');
 }
 function HasStringKeywords(schema) {
-    return S.IsSchema(schema) && (S.IsMinLength(schema) ||
+    return S.IsSchemaObject(schema) && (S.IsMinLength(schema) ||
         S.IsMaxLength(schema) ||
         S.IsFormat(schema) ||
         S.IsPattern(schema));
@@ -107,7 +107,7 @@ function HasNumberType(schema) {
     return HasTypeName(schema, 'number') || HasTypeName(schema, 'bigint');
 }
 function HasNumberKeywords(schema) {
-    return S.IsSchema(schema) && (S.IsMinimum(schema) ||
+    return S.IsSchemaObject(schema) && (S.IsMinimum(schema) ||
         S.IsMaximum(schema) ||
         S.IsExclusiveMaximum(schema) ||
         S.IsExclusiveMinimum(schema) ||

package/build/schema/errors.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
-import { type XSchemaLike } from './types/index.mjs';
+import { type XSchema } from './types/index.mjs';
 /** Checks a value and returns validation errors */
-export declare function Errors(schema: XSchemaLike, value: unknown): [boolean, TLocalizedValidationError[]];
+export declare function Errors(schema: XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
 /** Checks a value and returns validation errors */
-export declare function Errors(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): [boolean, TLocalizedValidationError[]];
+export declare function Errors(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): [boolean, TLocalizedValidationError[]];

package/build/schema/schema.d.mts

@@ -1,4 +1,5 @@
 export * from './engine/index.mjs';
+export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';
 export * from './check.mjs';

package/build/schema/schema.mjs

@@ -1,4 +1,5 @@
 export * from './engine/index.mjs';
+export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';
 export * from './check.mjs';

package/build/schema/static/additionalProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAdditionalProperties<Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Schema>;
+})> = Result;

package/build/schema/static/allOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAllOf<Schemas extends XSchema[], Result extends unknown = unknown> = (Schemas extends readonly [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAllOf<Right, Result & XStaticSchema<Left>> : Result);

package/build/schema/static/allOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/anyOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAnyOf<Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAnyOf<Right, XStaticSchema<Left> | Result> : Result);

package/build/schema/static/anyOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/const.d.mts

@@ -0,0 +1 @@
+export type XStaticConst<Value extends unknown> = Value;

package/build/schema/static/const.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/enum.d.mts

@@ -0,0 +1 @@
+export type XStaticEnum<Values extends unknown[], Result extends unknown = never> = (Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XStaticEnum<Right, Left | Result> : Result);

package/build/schema/static/enum.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/index.d.mts

@@ -0,0 +1 @@
+export type { XStatic } from './static.mjs';

package/build/schema/static/index.mjs

@@ -0,0 +1 @@
+export {};

package/build/schema/static/items.d.mts

@@ -0,0 +1,6 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type TFromUnsized<Schema extends XSchema> = (XStaticSchema<Schema>[]);
+type TFromSized<Schema extends XSchema[], Result extends unknown[] = []> = (Schema extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? TFromSized<Right, [...Result, XStaticSchema<Left>]> : Result);
+export type XStaticItems<Schemas extends XSchema[] | XSchema, Result extends unknown = (Schemas extends XSchema[] ? TFromSized<[...Schemas]> : Schemas extends XSchema ? TFromUnsized<Schemas> : never)> = Result;
+export {};

package/build/schema/static/items.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/oneOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticOneOf<Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticOneOf<Right, XStaticSchema<Left> | Result> : Result);

package/build/schema/static/oneOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/patternProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPatternProperties<Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>, InferredProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: XStaticSchema<Properties[Key]>;
+}, EvaluatedProperties extends unknown = {
+    [key: string]: InferredProperties[keyof InferredProperties];
+}> = EvaluatedProperties;

package/build/schema/static/patternProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/prefixItems.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPrefixItems<Schemas extends XSchema[], Result extends unknown[] = []> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticPrefixItems<Right, [...Result, XStaticSchema<Left>]> : Result);

package/build/schema/static/prefixItems.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/properties.d.mts

@@ -0,0 +1,11 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { TIsReadonly } from './~readonly.mjs';
+type TReadonlyOptionalProperties<Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in keyof Properties as TIsReadonly<Properties[Key]> extends true ? Key : never]?: XStaticSchema<Properties[Key]>;
+};
+type TOptionalProperties<Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in keyof Properties as TIsReadonly<Properties[Key]> extends true ? never : Key]?: XStaticSchema<Properties[Key]>;
+};
+export type XStaticProperties<Properties extends Record<PropertyKey, XSchema>, ReadonlyOptional extends Record<PropertyKey, unknown> = TReadonlyOptionalProperties<Properties>, Optional extends Record<PropertyKey, unknown> = TOptionalProperties<Properties>, Result extends Record<PropertyKey, unknown> = ReadonlyOptional & Optional> = Result;
+export {};

package/build/schema/static/properties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/required.d.mts

@@ -0,0 +1,13 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { TIsReadonly } from './~readonly.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type TResolveProperties<Schema extends XSchema, Result extends Record<PropertyKey, XSchema> = (Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? Properties : {})> = Result;
+type TFromKey<Properties extends Record<PropertyKey, XSchema>, Key extends string, Readonly extends boolean = Key extends keyof Properties ? TIsReadonly<Properties[Key]> : false, Value extends unknown = Key extends keyof Properties ? XStaticSchema<Properties[Key]> : unknown, Result extends Record<PropertyKey, unknown> = (Readonly extends true ? {
+    readonly [_ in Key]: Value;
+} : {
+    [_ in Key]: Value;
+})> = Result;
+type TFromKeys<Properties extends Record<PropertyKey, XSchema>, Keys extends string[], Result extends Record<PropertyKey, unknown> = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TFromKeys<Properties, Right, Result & TFromKey<Properties, Left>> : Result);
+export type XStaticRequired<Schema extends XSchema, Keys extends string[], Properties extends Record<PropertyKey, XSchema> = TResolveProperties<Schema>, Result extends Record<PropertyKey, unknown> = TFromKeys<Properties, Keys>> = Result;
+export {};

package/build/schema/static/required.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/schema.d.mts

@@ -0,0 +1,48 @@
+import type { XAdditionalProperties } from '../types/additionalProperties.mjs';
+import type { XAnyOf } from '../types/anyOf.mjs';
+import type { XAllOf } from '../types/allOf.mjs';
+import type { XConst } from '../types/const.mjs';
+import type { XEnum } from '../types/enum.mjs';
+import type { XItems } from '../types/items.mjs';
+import type { XOneOf } from '../types/oneOf.mjs';
+import type { XPatternProperties } from '../types/patternProperties.mjs';
+import type { XPrefixItems } from '../types/prefixItems.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XSchema } from '../types/schema.mjs';
+import type { XType } from '../types/type.mjs';
+import type { XUnevaluatedProperties } from '../types/unevaluatedProperties.mjs';
+import type { XStaticAdditionalProperties } from './additionalProperties.mjs';
+import type { XStaticAllOf } from './allOf.mjs';
+import type { XStaticAnyOf } from './anyOf.mjs';
+import type { XStaticConst } from './const.mjs';
+import type { XStaticEnum } from './enum.mjs';
+import type { XStaticItems } from './items.mjs';
+import type { XStaticOneOf } from './oneOf.mjs';
+import type { XStaticPatternProperties } from './patternProperties.mjs';
+import type { XStaticPrefixItems } from './prefixItems.mjs';
+import type { XStaticProperties } from './properties.mjs';
+import type { XStaticRequired } from './required.mjs';
+import type { XStaticType } from './type.mjs';
+import type { XStaticUnevaluatedProperties } from './unevaluatedProperties.mjs';
+type TFromKeywords<Schema, Result extends unknown[] = [
+    Schema extends XAdditionalProperties<infer Type extends XSchema> ? XStaticAdditionalProperties<Type> : unknown,
+    Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Types> : unknown,
+    Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Types> : unknown,
+    Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
+    Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Types> : unknown,
+    Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Types> : unknown,
+    Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Properties> : unknown,
+    Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Types> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Properties> : unknown,
+    Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Schema, Keys> : unknown,
+    Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,
+    Schema extends XUnevaluatedProperties<infer Type extends XSchema> ? XStaticUnevaluatedProperties<Type> : unknown
+]> = Result;
+type TKeywordsIntersected<Schemas extends unknown[], Result extends unknown = unknown> = (Schemas extends [infer Left extends unknown, ...infer Right extends unknown[]] ? TKeywordsIntersected<Right, Result & Left> : Result);
+type TKeywordsEvaluated<Schema extends unknown, Result extends unknown = Schema extends object ? {
+    [Key in keyof Schema]: Schema[Key];
+} : Schema> = Result;
+export type XStaticSchema<Schema extends XSchema, Keywords extends unknown[] = TFromKeywords<Schema>, Intersected extends unknown = TKeywordsIntersected<Keywords>, Evaluated extends unknown = TKeywordsEvaluated<Intersected>> = Evaluated;
+export {};

package/build/schema/static/schema.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/static.d.mts

@@ -0,0 +1,5 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XMutable } from './~mutable.mjs';
+/** Statically infers a JSON Schema */
+export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, Mutable extends XSchema = XMutable<Schema>, Result extends unknown = XStaticSchema<Mutable>> = Result;

package/build/schema/static/static.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/type.d.mts

@@ -0,0 +1,4 @@
+type TFromTypeNames<TypeNames extends string[], Result extends unknown = never> = (TypeNames extends readonly [infer Left extends string, ...infer Right extends string[]] ? TFromTypeNames<Right, Result | TFromTypeName<Left>> : Result);
+type TFromTypeName<TypeName extends string> = (TypeName extends 'array' ? {} : TypeName extends 'bigint' ? bigint : TypeName extends 'boolean' ? boolean : TypeName extends 'integer' ? number : TypeName extends 'object' ? object : TypeName extends 'null' ? null : TypeName extends 'number' ? number : TypeName extends 'string' ? string : TypeName extends 'symbol' ? symbol : TypeName extends 'undefined' ? undefined : unknown);
+export type XStaticType<TypeName extends string[] | string> = (TypeName extends string[] ? TFromTypeNames<TypeName> : TypeName extends string ? TFromTypeName<TypeName> : unknown);
+export {};

package/build/schema/static/type.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/unevaluatedProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticUnevaluatedProperties<Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Schema>;
+})> = Result;

package/build/schema/static/unevaluatedProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/~mutable.d.mts

@@ -0,0 +1,7 @@
+type TFromTuple<Value extends readonly unknown[]> = (Value extends [infer Left, ...infer Right extends unknown[]] ? [XMutable<Left>, ...TFromTuple<Right>] : []);
+type TFromArray<Value extends unknown, Result extends unknown[] = XMutable<Value>[]> = Result;
+type TFromObject<Value extends object, Result extends Record<PropertyKey, unknown> = {
+    -readonly [K in keyof Value]: XMutable<Value[K]>;
+}> = Result;
+export type XMutable<Value extends unknown> = (Value extends readonly [...infer Schemas extends unknown[]] ? TFromTuple<Schemas> : Value extends readonly (infer Schema)[] ? TFromArray<Schema> : Value extends object ? TFromObject<Value> : Value);
+export {};

package/build/schema/static/~mutable.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/~readonly.d.mts

@@ -0,0 +1,6 @@
+import type { XSchema } from '../types/schema.mjs';
+export type TIsReadonly<Schema extends XSchema> = (Schema extends {
+    readOnly: true;
+} ? true : Schema extends {
+    '~readonly': true;
+} ? true : false);

package/build/schema/static/~readonly.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/types/_guard.d.mts

@@ -1,4 +1,4 @@
-import type { XSchema } from './schema.mjs';
+import type { XSchemaObject } from './schema.mjs';
 export interface XGuardInterface<Value extends unknown = unknown> {
     check(value: unknown): value is Value;
     errors(value: unknown): object[];
@@ -7,4 +7,4 @@ export interface XGuard<Value extends unknown = unknown> {
     '~guard': XGuardInterface<Value>;
 }
 export declare function IsGuardInterface(value: unknown): value is XGuardInterface;
-export declare function IsGuard(value: XSchema): value is XGuard;
+export declare function IsGuard(value: XSchemaObject): value is XGuard;

package/build/schema/types/_refine.d.mts

@@ -1,4 +1,4 @@
-import type { XSchema } from './schema.mjs';
+import type { XSchemaObject } from './schema.mjs';
 export interface XRefinement {
     refine: (value: unknown) => boolean;
     message: string;
@@ -10,4 +10,4 @@ export interface XRefine<Refinements extends XRefinement[] = XRefinement[]> {
  * Returns true if the schema contains an '~refine` keyword
  * @specification None
  */
-export declare function IsRefine(value: XSchema): value is XRefine;
+export declare function IsRefine(value: XSchemaObject): value is XRefine;

package/build/schema/types/additionalItems.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from '../types/schema.mjs';
-export interface XAdditionalItems<AdditionalItems extends XSchemaLike = XSchemaLike> {
+import { type XSchemaObject, type XSchema } from '../types/schema.mjs';
+export interface XAdditionalItems<AdditionalItems extends XSchema = XSchema> {
     additionalItems: AdditionalItems;
 }
 /**
  * Returns true if the schema contains a valid additionalItems property
  * @specification Json Schema 7
  */
-export declare function IsAdditionalItems(schema: XSchema): schema is XAdditionalItems;
+export declare function IsAdditionalItems(schema: XSchemaObject): schema is XAdditionalItems;

package/build/schema/types/additionalItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from '../types/schema.mjs';
+import { IsSchema } from '../types/schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from '../types/schema.mjs';
  */
 export function IsAdditionalItems(schema) {
     return Guard.HasPropertyKey(schema, 'additionalItems')
-        && IsSchemaLike(schema.additionalItems);
+        && IsSchema(schema.additionalItems);
 }

package/build/schema/types/additionalProperties.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XAdditionalProperties<AdditionalProperties extends XSchemaLike = XSchemaLike> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAdditionalProperties<AdditionalProperties extends XSchema = XSchema> {
     additionalProperties: AdditionalProperties;
 }
 /**
  * Returns true if the schema contains a valid additionalProperties property
  * @specification Json Schema 7
  */
-export declare function IsAdditionalProperties(schema: XSchema): schema is XAdditionalProperties;
+export declare function IsAdditionalProperties(schema: XSchemaObject): schema is XAdditionalProperties;

package/build/schema/types/additionalProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from './schema.mjs';
  */
 export function IsAdditionalProperties(schema) {
     return Guard.HasPropertyKey(schema, 'additionalProperties')
-        && IsSchemaLike(schema.additionalProperties);
+        && IsSchema(schema.additionalProperties);
 }

package/build/schema/types/allOf.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XAllOf<AllOf extends XSchemaLike[] = XSchemaLike[]> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAllOf<AllOf extends XSchema[] = XSchema[]> {
     allOf: AllOf;
 }
 /**
  * Returns true if the schema contains a valid allOf property
  * @specification Json Schema 7
  */
-export declare function IsAllOf(schema: XSchema): schema is XAllOf;
+export declare function IsAllOf(schema: XSchemaObject): schema is XAllOf;

package/build/schema/types/allOf.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -11,5 +11,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsAllOf(schema) {
     return Guard.HasPropertyKey(schema, 'allOf')
         && Guard.IsArray(schema.allOf)
-        && schema.allOf.every(value => IsSchemaLike(value));
+        && schema.allOf.every(value => IsSchema(value));
 }

package/build/schema/types/anyOf.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XAnyOf<AnyOf extends XSchemaLike[] = XSchemaLike[]> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAnyOf<AnyOf extends XSchema[] = XSchema[]> {
     anyOf: AnyOf;
 }
 /**
  * Returns true if the schema contains a valid anyOf property
  * @specification Json Schema 7
  */
-export declare function IsAnyOf(schema: XSchema): schema is XAnyOf;
+export declare function IsAnyOf(schema: XSchemaObject): schema is XAnyOf;