typebox 0.0.1 → 1.0.0

package/build/schema/schema.d.mts

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

package/build/schema/schema.mjs

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

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

@@ -0,0 +1,13 @@
+import type { XSchema } from './schema.mjs';
+export interface XRefinement {
+    callback: (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: XSchema): 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'], value => Guard.IsObject(value)
+            && Guard.HasPropertyKey(value, 'callback')
+            && Guard.HasPropertyKey(value, 'message')
+            && Guard.IsFunction(value.callback)
+            && Guard.IsString(value.message));
+}

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

@@ -0,0 +1,14 @@
+import type { XSchema } from './schema.mjs';
+export interface XStandardValidatorV1 {
+    version: 1;
+    vendor: string;
+    validate: (...args: unknown[]) => object;
+}
+export interface XStandardSchemaV1<Validator extends XStandardValidatorV1 = XStandardValidatorV1> {
+    '~standard': Validator;
+}
+/**
+ * Returns true if the schema contains an '~standard` keyword
+ * @specification 'StandardSchema'
+ */
+export declare function IsStandardSchemaV1(value: XSchema): value is XStandardSchemaV1;

package/build/schema/types/_standard.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains an '~standard` keyword
+ * @specification 'StandardSchema'
+ */
+export function IsStandardSchemaV1(value) {
+    return Guard.HasPropertyKey(value, '~standard')
+        && Guard.IsObject(value["~standard"])
+        && Guard.HasPropertyKey(value['~standard'], 'version')
+        && Guard.HasPropertyKey(value['~standard'], 'vendor')
+        && Guard.HasPropertyKey(value['~standard'], 'validate')
+        && Guard.IsEqual(value['~standard'].version, 1)
+        && Guard.IsString(value['~standard'].vendor)
+        && Guard.IsFunction(value['~standard'].validate);
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from '../types/schema.mjs';
+export interface XAdditionalItems<AdditionalItems extends XSchemaLike = XSchemaLike> {
+    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;

package/build/schema/types/additionalItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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')
+        && IsSchemaLike(schema.additionalItems);
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XAdditionalProperties<AdditionalProperties extends XSchemaLike = XSchemaLike> {
+    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;

package/build/schema/types/additionalProperties.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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')
+        && IsSchemaLike(schema.additionalProperties);
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XAllOf<AllOf extends XSchemaLike[] = XSchemaLike[]> {
+    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;

package/build/schema/types/allOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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 => IsSchemaLike(value));
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XAnyOf<AnyOf extends XSchemaLike[] = XSchemaLike[]> {
+    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;

package/build/schema/types/anyOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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 => IsSchemaLike(value));
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema } 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: XSchema): 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 XSchema, type XSchemaLike } from './schema.mjs';
+export interface XContains<Contains extends XSchemaLike = XSchemaLike> {
+    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;

package/build/schema/types/contains.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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')
+        && IsSchemaLike(schema.contains);
+}

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

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

package/build/schema/types/defs.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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 => IsSchemaLike(value));
+}

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

@@ -0,0 +1,11 @@
+import { type XSchema } 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: XSchema): 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 { IsSchemaLike } 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 => IsSchemaLike(value)
+            || Guard.IsArray(value) && value.every(value => Guard.IsString(value)));
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema } 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: XSchema): 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 XSchema, type XSchemaLike } from './schema.mjs';
+export interface XDependentSchemas<DependentSchemas extends Record<PropertyKey, XSchemaLike> = Record<PropertyKey, XSchemaLike>> {
+    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;

package/build/schema/types/dependentSchemas.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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 => IsSchemaLike(value));
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XElse<Else extends XSchemaLike = XSchemaLike> {
+    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;

package/build/schema/types/else.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } 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')
+        && IsSchemaLike(schema.else);
+}

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

@@ -0,0 +1,9 @@
+import { type XSchema } 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: XSchema): 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 XSchema } 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: XSchema): 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 XSchema } 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: XSchema): 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));
+}

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

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

package/build/schema/types/format.mjs

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

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

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

package/build/schema/types/id.mjs

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

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

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XIf<If extends XSchemaLike = XSchemaLike> {
+    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;

package/build/schema/types/if.mjs

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