@depup/typebox 1.1.6-depup.0

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

@@ -0,0 +1,18 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XMinItems } from '../types/minItems.mjs';
+import type { XMaxItems } from '../types/maxItems.mjs';
+import type { XAdditionalItems } from '../types/additionalItems.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XLessThan } from './~comparer.mjs';
+type XWithElements<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown[] = []> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XWithElements<Stack, Root, Right, [...Result, XStaticSchema<Stack, Root, Left>]> : Result);
+type XWithMaxItemsRemap<Elements extends unknown[], MaxItems extends number, Result extends unknown[] = []> = (Elements extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XLessThan<Result['length'], MaxItems> extends true ? XWithMaxItemsRemap<Right, MaxItems, [...Result, Left]> : Result : Result);
+type XWithMaxItems<Schema extends XSchema, Elements extends unknown[], MaxItems extends number | null = Schema extends XMaxItems<infer MaxItems extends number> ? MaxItems : null, Result extends unknown[] = MaxItems extends number ? XWithMaxItemsRemap<Elements, MaxItems> : Elements> = Result;
+type XNeedsAdditionalItems<Schema extends XSchema, Elements extends unknown[], MaxItems extends number | null = Schema extends XMaxItems<infer MaxItems extends number> ? MaxItems : null, Result extends boolean = MaxItems extends number ? XLessThan<Elements['length'], MaxItems> : true> = Result;
+type XWithMinItemsRemap<Elements extends unknown[], MinItems extends number, Result extends unknown[] = []> = (Elements extends [infer Left, ...infer Right] ? XLessThan<Result['length'], MinItems> extends true ? XWithMinItemsRemap<Right, MinItems, [...Result, Left]> : XWithMinItemsRemap<Right, MinItems, [...Result, Left?]> : Result);
+type XWithMinItems<Schema extends XSchema, Values extends unknown[], MinItems extends number = Schema extends XMinItems<infer MinItems extends number> ? MinItems : 0, Result extends unknown[] = XWithMinItemsRemap<Values, MinItems>> = Result;
+type XWithAdditionalItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, Elements extends unknown[], Result extends unknown[] = Schema extends XAdditionalItems<infer Schema extends XSchema> ? (Schema extends true ? [...Elements, ...unknown[]] : Schema extends false ? [...Elements] : [
+    ...Elements,
+    ...XStaticSchema<Stack, Root, Schema>[]
+]) : [...Elements, ...unknown[]]> = Result;
+export type XStaticElements<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], WithElements extends unknown[] = XWithElements<Stack, Root, PrefixItems>, WithMaxItems extends unknown[] = XWithMaxItems<Schema, WithElements>, NeedsAdditional extends boolean = XNeedsAdditionalItems<Schema, WithMaxItems>, WithMinItems extends unknown[] = XWithMinItems<Schema, WithMaxItems>, WithAdditionalItems extends unknown[] = NeedsAdditional extends true ? XWithAdditionalItems<Stack, Root, Schema, WithMinItems> : WithMinItems> = WithAdditionalItems;
+export {};

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

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

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

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

package/build/schema/static/~non-readonly.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 XIsReadonly<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

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

package/build/schema/types/_guard.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsGuardInterface(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'errors')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.errors);
+}
+export function IsGuard(value) {
+    return Guard.HasPropertyKey(value, '~guard')
+        && IsGuardInterface(value['~guard']);
+}

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

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

package/build/schema/types/_refine.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains an '~refine` keyword
+ * @specification None
+ */
+export function IsRefine(value) {
+    return Guard.HasPropertyKey(value, '~refine')
+        && Guard.IsArray(value["~refine"])
+        && Guard.Every(value['~refine'], 0, value => Guard.IsObject(value)
+            && Guard.HasPropertyKey(value, 'refine')
+            && Guard.HasPropertyKey(value, 'message')
+            && Guard.IsFunction(value.refine)
+            && Guard.IsString(value.message));
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XAdditionalItems;

package/build/schema/types/additionalItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid additionalItems property
+ * @specification Json Schema 7
+ */
+export function IsAdditionalItems(schema) {
+    return Guard.HasPropertyKey(schema, 'additionalItems')
+        && IsSchema(schema.additionalItems);
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XAdditionalProperties;

package/build/schema/types/additionalProperties.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid additionalProperties property
+ * @specification Json Schema 7
+ */
+export function IsAdditionalProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'additionalProperties')
+        && IsSchema(schema.additionalProperties);
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XAllOf;

package/build/schema/types/allOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid allOf property
+ * @specification Json Schema 7
+ */
+export function IsAllOf(schema) {
+    return Guard.HasPropertyKey(schema, 'allOf')
+        && Guard.IsArray(schema.allOf)
+        && schema.allOf.every(value => IsSchema(value));
+}

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

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XAnchor<Anchor extends string = string> {
+    $anchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $anchor property
+ */
+export declare function IsAnchor(schema: XSchemaObject): schema is XAnchor;

package/build/schema/types/anchor.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $anchor property
+ */
+export function IsAnchor(schema) {
+    return Guard.HasPropertyKey(schema, '$anchor')
+        && Guard.IsString(schema.$anchor);
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XAnyOf;

package/build/schema/types/anyOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid anyOf property
+ * @specification Json Schema 7
+ */
+export function IsAnyOf(schema) {
+    return Guard.HasPropertyKey(schema, 'anyOf')
+        && Guard.IsArray(schema.anyOf)
+        && schema.anyOf.every(value => IsSchema(value));
+}

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

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

package/build/schema/types/const.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid const property
+ * @specification Json Schema 7
+ */
+export function IsConst(value) {
+    return Guard.HasPropertyKey(value, 'const');
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XContains;

package/build/schema/types/contains.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contains property
+ * @specification Json Schema 7
+ */
+export function IsContains(schema) {
+    return Guard.HasPropertyKey(schema, 'contains')
+        && IsSchema(schema.contains);
+}

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

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

package/build/schema/types/contentEncoding.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentEncoding property
+ * @specification Json Schema 7
+ */
+export function IsContentEncoding(schema) {
+    return Guard.HasPropertyKey(schema, 'contentEncoding')
+        && Guard.IsString(schema.contentEncoding);
+}

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

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

package/build/schema/types/contentMediaType.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export function IsContentMediaType(schema) {
+    return Guard.HasPropertyKey(schema, 'contentMediaType')
+        && Guard.IsString(schema.contentMediaType);
+}

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

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

package/build/schema/types/default.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export function IsDefault(schema) {
+    return Guard.HasPropertyKey(schema, 'default');
+}

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

@@ -0,0 +1,6 @@
+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: XSchemaObject): schema is XDefs;

package/build/schema/types/defs.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the schema contains a valid $defs property */
+export function IsDefs(schema) {
+    return Guard.HasPropertyKey(schema, '$defs')
+        && Guard.IsObject(schema.$defs)
+        && Object.values(schema.$defs).every(value => IsSchema(value));
+}

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

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

package/build/schema/types/dependencies.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependencies property
+ * @specification Json Schema 7
+ */
+export function IsDependencies(schema) {
+    return Guard.HasPropertyKey(schema, 'dependencies')
+        && Guard.IsObject(schema.dependencies)
+        && Object.values(schema.dependencies).every(value => IsSchema(value)
+            || Guard.IsArray(value) && value.every(value => Guard.IsString(value)));
+}

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

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

package/build/schema/types/dependentRequired.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export function IsDependentRequired(schema) {
+    return Guard.HasPropertyKey(schema, 'dependentRequired')
+        && Guard.IsObject(schema.dependentRequired)
+        && Object.values(schema.dependentRequired).every(value => Guard.IsArray(value)
+            && value.every(value => Guard.IsString(value)));
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XDependentSchemas;

package/build/schema/types/dependentSchemas.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export function IsDependentSchemas(schema) {
+    return Guard.HasPropertyKey(schema, 'dependentSchemas')
+        && Guard.IsObject(schema.dependentSchemas)
+        && Object.values(schema.dependentSchemas).every(value => IsSchema(value));
+}

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

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDynamicAnchor<Anchor extends string = string> {
+    $dynamicAnchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $dynamicAnchor property
+ */
+export declare function IsDynamicAnchor(schema: XSchemaObject): schema is XDynamicAnchor;

package/build/schema/types/dynamicAnchor.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $dynamicAnchor property
+ */
+export function IsDynamicAnchor(schema) {
+    return Guard.HasPropertyKey(schema, '$dynamicAnchor')
+        && Guard.IsString(schema.$dynamicAnchor);
+}

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

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDynamicRef<Ref extends string = string> {
+    $dynamicRef: Ref;
+}
+/**
+ * Returns true if the schema contains a valid $dynamicRef property
+ */
+export declare function IsDynamicRef(schema: XSchemaObject): schema is XDynamicRef;

package/build/schema/types/dynamicRef.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $dynamicRef property
+ */
+export function IsDynamicRef(schema) {
+    return Guard.HasPropertyKey(schema, '$dynamicRef')
+        && Guard.IsString(schema.$dynamicRef);
+}

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

@@ -0,0 +1,9 @@
+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: XSchemaObject): schema is XElse;

package/build/schema/types/else.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid else property
+ * @specification Json Schema 7
+ */
+export function IsElse(schema) {
+    return Guard.HasPropertyKey(schema, 'else')
+        && IsSchema(schema.else);
+}

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

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

package/build/schema/types/enum.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid enum property
+ * @specification Json Schema 7
+ */
+export function IsEnum(schema) {
+    return Guard.HasPropertyKey(schema, 'enum')
+        && Guard.IsArray(schema.enum);
+}

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

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

package/build/schema/types/exclusiveMaximum.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid exclusiveMaximum property
+ * @specification Json Schema 7
+ */
+export function IsExclusiveMaximum(schema) {
+    return Guard.HasPropertyKey(schema, 'exclusiveMaximum')
+        && (Guard.IsNumber(schema.exclusiveMaximum) || Guard.IsBigInt(schema.exclusiveMaximum));
+}

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

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

package/build/schema/types/exclusiveMinimum.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid exclusiveMinimum property
+ * @specification Json Schema 7
+ */
+export function IsExclusiveMinimum(schema) {
+    return Guard.HasPropertyKey(schema, 'exclusiveMinimum')
+        && (Guard.IsNumber(schema.exclusiveMinimum) || Guard.IsBigInt(schema.exclusiveMinimum));
+}