typebox 1.0.36 → 1.0.37

package/build/schema/types/anyOf.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 IsAnyOf(schema) {
     return Guard.HasPropertyKey(schema, 'anyOf')
         && Guard.IsArray(schema.anyOf)
-        && schema.anyOf.every(value => IsSchemaLike(value));
+        && schema.anyOf.every(value => IsSchema(value));
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XConst<Const extends unknown = unknown> {
     const: Const;
 }
@@ -6,4 +6,4 @@ export interface XConst<Const extends unknown = unknown> {
  * Returns true if the schema contains a valid const property
  * @specification Json Schema 7
  */
-export declare function IsConst(value: XSchema): value is XConst;
+export declare function IsConst(value: XSchemaObject): value is XConst;

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

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

package/build/schema/types/contains.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 IsContains(schema) {
     return Guard.HasPropertyKey(schema, 'contains')
-        && IsSchemaLike(schema.contains);
+        && IsSchema(schema.contains);
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XContentEncoding<ContentEncoding extends string = string> {
     contentEncoding: ContentEncoding;
 }
@@ -6,4 +6,4 @@ export interface XContentEncoding<ContentEncoding extends string = string> {
  * Returns true if the schema contains a valid contentEncoding property
  * @specification Json Schema 7
  */
-export declare function IsContentEncoding(schema: XSchema): schema is XContentEncoding;
+export declare function IsContentEncoding(schema: XSchemaObject): schema is XContentEncoding;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XContentMediaType<ContentMediaType extends string = string> {
     contentMediaType: ContentMediaType;
 }
@@ -6,4 +6,4 @@ export interface XContentMediaType<ContentMediaType extends string = string> {
  * Returns true if the schema contains a valid contentMediaType property
  * @specification Json Schema 7
  */
-export declare function IsContentMediaType(schema: XSchema): schema is XContentMediaType;
+export declare function IsContentMediaType(schema: XSchemaObject): schema is XContentMediaType;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XDefault<Default extends unknown = unknown> {
     default: Default;
 }
@@ -6,4 +6,4 @@ export interface XDefault<Default extends unknown = unknown> {
  * Returns true if the schema contains a valid contentMediaType property
  * @specification Json Schema 7
  */
-export declare function IsDefault(schema: XSchema): schema is XDefault;
+export declare function IsDefault(schema: XSchemaObject): schema is XDefault;

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

@@ -1,6 +1,6 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XDefs<Defs extends Record<PropertyKey, XSchemaLike> = Record<PropertyKey, XSchemaLike>> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDefs<Defs extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
     $defs: Defs;
 }
 /** Returns true if the schema contains a valid $defs property */
-export declare function IsDefs(schema: XSchema): schema is XDefs;
+export declare function IsDefs(schema: XSchemaObject): schema is XDefs;

package/build/schema/types/defs.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
 // ------------------------------------------------------------------
@@ -8,5 +8,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsDefs(schema) {
     return Guard.HasPropertyKey(schema, '$defs')
         && Guard.IsObject(schema.$defs)
-        && Object.values(schema.$defs).every(value => IsSchemaLike(value));
+        && Object.values(schema.$defs).every(value => IsSchema(value));
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 type XDependenciesProperty = Record<PropertyKey, boolean | Record<PropertyKey, unknown> | string[]>;
 export interface XDependencies<Dependencies extends XDependenciesProperty = XDependenciesProperty> {
     dependencies: Dependencies;
@@ -7,5 +7,5 @@ export interface XDependencies<Dependencies extends XDependenciesProperty = XDep
  * Returns true if the schema contains a valid dependencies property
  * @specification Json Schema 7
  */
-export declare function IsDependencies(schema: XSchema): schema is XDependencies;
+export declare function IsDependencies(schema: XSchemaObject): schema is XDependencies;
 export {};

package/build/schema/types/dependencies.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,6 +11,6 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsDependencies(schema) {
     return Guard.HasPropertyKey(schema, 'dependencies')
         && Guard.IsObject(schema.dependencies)
-        && Object.values(schema.dependencies).every(value => IsSchemaLike(value)
+        && Object.values(schema.dependencies).every(value => IsSchema(value)
             || Guard.IsArray(value) && value.every(value => Guard.IsString(value)));
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XDependentRequired<DependentRequired extends Record<PropertyKey, string[]> = Record<PropertyKey, string[]>> {
     dependentRequired: DependentRequired;
 }
@@ -6,4 +6,4 @@ export interface XDependentRequired<DependentRequired extends Record<PropertyKey
  * Returns true if the schema contains a valid dependentRequired property
  * @specification Json Schema 2019-09
  */
-export declare function IsDependentRequired(schema: XSchema): schema is XDependentRequired;
+export declare function IsDependentRequired(schema: XSchemaObject): schema is XDependentRequired;

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

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XDependentSchemas<DependentSchemas extends Record<PropertyKey, XSchemaLike> = Record<PropertyKey, XSchemaLike>> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDependentSchemas<DependentSchemas extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
     dependentSchemas: DependentSchemas;
 }
 /**
  * Returns true if the schema contains a valid dependentRequired property
  * @specification Json Schema 2019-09
  */
-export declare function IsDependentSchemas(schema: XSchema): schema is XDependentSchemas;
+export declare function IsDependentSchemas(schema: XSchemaObject): schema is XDependentSchemas;

package/build/schema/types/dependentSchemas.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 IsDependentSchemas(schema) {
     return Guard.HasPropertyKey(schema, 'dependentSchemas')
         && Guard.IsObject(schema.dependentSchemas)
-        && Object.values(schema.dependentSchemas).every(value => IsSchemaLike(value));
+        && Object.values(schema.dependentSchemas).every(value => IsSchema(value));
 }

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

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

package/build/schema/types/else.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 IsElse(schema) {
     return Guard.HasPropertyKey(schema, 'else')
-        && IsSchemaLike(schema.else);
+        && IsSchema(schema.else);
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XEnum<Enum extends unknown[] = unknown[]> {
     enum: Enum;
 }
@@ -6,4 +6,4 @@ export interface XEnum<Enum extends unknown[] = unknown[]> {
  * Returns true if the schema contains a valid enum property
  * @specification Json Schema 7
  */
-export declare function IsEnum(schema: XSchema): schema is XEnum;
+export declare function IsEnum(schema: XSchemaObject): schema is XEnum;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XExclusiveMaximum<ExclusiveMaximum extends number | bigint = number | bigint> {
     exclusiveMaximum: ExclusiveMaximum;
 }
@@ -6,4 +6,4 @@ export interface XExclusiveMaximum<ExclusiveMaximum extends number | bigint = nu
  * Returns true if the schema contains a valid exclusiveMaximum property
  * @specification Json Schema 7
  */
-export declare function IsExclusiveMaximum(schema: XSchema): schema is XExclusiveMaximum;
+export declare function IsExclusiveMaximum(schema: XSchemaObject): schema is XExclusiveMaximum;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XExclusiveMinimum<ExclusiveMinimum extends number | bigint = number | bigint> {
     exclusiveMinimum: ExclusiveMinimum;
 }
@@ -6,4 +6,4 @@ export interface XExclusiveMinimum<ExclusiveMinimum extends number | bigint = nu
  * Returns true if the schema contains a valid exclusiveMinimum property
  * @specification Json Schema 7
  */
-export declare function IsExclusiveMinimum(schema: XSchema): schema is XExclusiveMinimum;
+export declare function IsExclusiveMinimum(schema: XSchemaObject): schema is XExclusiveMinimum;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XFormat<Format extends string = string> {
     format: Format;
 }
@@ -6,4 +6,4 @@ export interface XFormat<Format extends string = string> {
  * Returns true if the schema contains a valid format property
  * @specification Json Schema 7
  */
-export declare function IsFormat(schema: XSchema): schema is XFormat;
+export declare function IsFormat(schema: XSchemaObject): schema is XFormat;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XId<Id extends string = string> {
     $id: Id;
 }
@@ -6,4 +6,4 @@ export interface XId<Id extends string = string> {
  * Returns true if the schema contains a valid $id property
  * @specification Json Schema 7
  */
-export declare function IsId(schema: XSchema): schema is XId;
+export declare function IsId(schema: XSchemaObject): schema is XId;

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

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

package/build/schema/types/if.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 IsIf(schema) {
     return Guard.HasPropertyKey(schema, 'if')
-        && IsSchemaLike(schema.if);
+        && IsSchema(schema.if);
 }

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

@@ -38,7 +38,6 @@ export * from './propertyNames.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';
-export * from './static.mjs';
 export * from './then.mjs';
 export * from './type.mjs';
 export * from './uniqueItems.mjs';

package/build/schema/types/index.mjs

@@ -44,7 +44,6 @@ export * from './propertyNames.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';
-export * from './static.mjs';
 export * from './then.mjs';
 export * from './type.mjs';
 export * from './uniqueItems.mjs';

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

@@ -1,19 +1,19 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XItemsSized<Items extends XSchemaLike[] = XSchemaLike[]> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XItemsSized<Items extends XSchema[] = XSchema[]> {
     items: Items;
 }
-export interface XItemsUnsized<Items extends XSchemaLike = XSchemaLike> {
+export interface XItemsUnsized<Items extends XSchema = XSchema> {
     items: Items;
 }
-export interface XItems<Items extends (XSchemaLike | XSchemaLike[]) = (XSchemaLike | XSchemaLike[])> {
+export interface XItems<Items extends (XSchema | XSchema[]) = (XSchema | XSchema[])> {
     items: Items;
 }
 /**
  * Returns true if the schema contains a valid items property
  * @specification Json Schema 7
  */
-export declare function IsItems(schema: XSchema): schema is XItems;
+export declare function IsItems(schema: XSchemaObject): schema is XItems;
 /** Returns true if this schema is a sized items variant */
-export declare function IsItemsSized(schema: XSchema): schema is XItemsSized;
+export declare function IsItemsSized(schema: XSchemaObject): schema is XItemsSized;
 /** Returns true if this schema is a unsized items variant */
-export declare function IsItemsUnsized(schema: XSchema): schema is XItemsUnsized;
+export declare function IsItemsUnsized(schema: XSchemaObject): schema is XItemsUnsized;

package/build/schema/types/items.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,10 +10,10 @@ import { IsSchemaLike } from './schema.mjs';
  */
 export function IsItems(schema) {
     return Guard.HasPropertyKey(schema, 'items')
-        && (IsSchemaLike(schema.items)
+        && (IsSchema(schema.items)
             || (Guard.IsArray(schema.items)
                 && schema.items.every(value => {
-                    return IsSchemaLike(value);
+                    return IsSchema(value);
                 })));
 }
 /** Returns true if this schema is a sized items variant */

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMaxContains<MaxContains extends number = number> {
     maxContains: MaxContains;
 }
@@ -6,4 +6,4 @@ export interface XMaxContains<MaxContains extends number = number> {
  * Returns true if the schema contains a valid maxContains property
  * @specification Json Schema 2019-09
  */
-export declare function IsMaxContains(schema: XSchema): schema is XMaxContains;
+export declare function IsMaxContains(schema: XSchemaObject): schema is XMaxContains;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMaxItems<MaxItems extends number = number> {
     maxItems: MaxItems;
 }
@@ -6,4 +6,4 @@ export interface XMaxItems<MaxItems extends number = number> {
  * Returns true if the schema contains a valid maxItems property
  * @specification Json Schema 7
  */
-export declare function IsMaxItems(schema: XSchema): schema is XMaxItems;
+export declare function IsMaxItems(schema: XSchemaObject): schema is XMaxItems;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMaxLength<MaxLength extends number = number> {
     maxLength: MaxLength;
 }
@@ -6,4 +6,4 @@ export interface XMaxLength<MaxLength extends number = number> {
  * Returns true if the schema contains a valid maxLength property
  * @specification Json Schema 7
  */
-export declare function IsMaxLength(schema: XSchema): schema is XMaxLength;
+export declare function IsMaxLength(schema: XSchemaObject): schema is XMaxLength;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMaxProperties<MaxProperties extends number = number> {
     maxProperties: MaxProperties;
 }
@@ -6,4 +6,4 @@ export interface XMaxProperties<MaxProperties extends number = number> {
  * Returns true if the schema contains a valid maxProperties property
  * @specification Json Schema 7
  */
-export declare function IsMaxProperties(schema: XSchema): schema is XMaxProperties;
+export declare function IsMaxProperties(schema: XSchemaObject): schema is XMaxProperties;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMaximum<Maximum extends number | bigint = number | bigint> {
     maximum: Maximum;
 }
@@ -6,4 +6,4 @@ export interface XMaximum<Maximum extends number | bigint = number | bigint> {
  * Returns true if the schema contains a valid maximum property
  * @specification Json Schema 7
  */
-export declare function IsMaximum(schema: XSchema): schema is XMaximum;
+export declare function IsMaximum(schema: XSchemaObject): schema is XMaximum;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMinContains<MinContains extends number = number> {
     minContains: MinContains;
 }
@@ -6,4 +6,4 @@ export interface XMinContains<MinContains extends number = number> {
  * Returns true if the schema contains a valid maxContains property
  * @specification Json Schema 2019-09
  */
-export declare function IsMinContains(schema: XSchema): schema is XMinContains;
+export declare function IsMinContains(schema: XSchemaObject): schema is XMinContains;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMinItems<MinItems extends number = number> {
     minItems: MinItems;
 }
@@ -6,4 +6,4 @@ export interface XMinItems<MinItems extends number = number> {
  * Returns true if the schema contains a valid minItems property
  * @specification Json Schema 7
  */
-export declare function IsMinItems(schema: XSchema): schema is XMinItems;
+export declare function IsMinItems(schema: XSchemaObject): schema is XMinItems;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMinLength<MinLength extends number = number> {
     minLength: MinLength;
 }
@@ -6,4 +6,4 @@ export interface XMinLength<MinLength extends number = number> {
  * Returns true if the schema contains a valid minLength property
  * @specification Json Schema 7
  */
-export declare function IsMinLength(schema: XSchema): schema is XMinLength;
+export declare function IsMinLength(schema: XSchemaObject): schema is XMinLength;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMinProperties<MinProperties extends number = number> {
     minProperties: MinProperties;
 }
@@ -6,4 +6,4 @@ export interface XMinProperties<MinProperties extends number = number> {
  * Returns true if the schema contains a valid minProperties property
  * @specification Json Schema 7
  */
-export declare function IsMinProperties(schema: XSchema): schema is XMinProperties;
+export declare function IsMinProperties(schema: XSchemaObject): schema is XMinProperties;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMinimum<Minimum extends number | bigint = number | bigint> {
     minimum: Minimum;
 }
@@ -6,4 +6,4 @@ export interface XMinimum<Minimum extends number | bigint = number | bigint> {
  * Returns true if the schema contains a valid minimum property
  * @specification Json Schema 7
  */
-export declare function IsMinimum(schema: XSchema): schema is XMinimum;
+export declare function IsMinimum(schema: XSchemaObject): schema is XMinimum;

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XMultipleOf<MultipleOf extends number | bigint = number | bigint> {
     multipleOf: MultipleOf;
 }
@@ -6,4 +6,4 @@ export interface XMultipleOf<MultipleOf extends number | bigint = number | bigin
  * Returns true if the schema contains a valid multipleOf property
  * @specification Json Schema 7
  */
-export declare function IsMultipleOf(schema: XSchema): schema is XMultipleOf;
+export declare function IsMultipleOf(schema: XSchemaObject): schema is XMultipleOf;

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

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

package/build/schema/types/not.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 IsNot(schema) {
     return Guard.HasPropertyKey(schema, 'not')
-        && IsSchemaLike(schema.not);
+        && IsSchema(schema.not);
 }

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

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

package/build/schema/types/oneOf.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 IsOneOf(schema) {
     return Guard.HasPropertyKey(schema, 'oneOf')
         && Guard.IsArray(schema.oneOf)
-        && schema.oneOf.every(value => IsSchemaLike(value));
+        && schema.oneOf.every(value => IsSchema(value));
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XPattern<Pattern extends string | RegExp = string | RegExp> {
     pattern: Pattern;
 }
@@ -6,4 +6,4 @@ export interface XPattern<Pattern extends string | RegExp = string | RegExp> {
  * Returns true if the schema contains a valid pattern property
  * @specification Json Schema 7
  */
-export declare function IsPattern(schema: XSchema): schema is XPattern;
+export declare function IsPattern(schema: XSchemaObject): schema is XPattern;

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

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