typebox 1.0.31 → 1.0.33

package/build/cjs/schema/deref/deref.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rebase = Rebase;
+exports.Deref = Deref;
+const index_1 = require("../../guard/index");
+const index_2 = require("../../format/index");
+const index_3 = require("../../value/pointer/index");
+const S = require("../types/index");
+// ------------------------------------------------------------------
+// Rebase
+// ------------------------------------------------------------------
+function Rebase(baseUri, schema) {
+    if (!S.IsId(schema))
+        return baseUri;
+    if ((0, index_2.IsUri)(schema.$id))
+        return schema.$id;
+    if (!(0, index_2.IsUri)(schema.$id) && (0, index_2.IsUri)(baseUri)) {
+        return new URL(schema.$id, baseUri).href;
+    }
+    return baseUri;
+}
+// ------------------------------------------------------------------
+// Select
+// ------------------------------------------------------------------
+function IsHashPointer(value) {
+    return IsHash(value) && (0, index_2.IsJsonPointer)(value.slice(1));
+}
+function IsHash(value) {
+    return value.length > 0 && value[0] === '#';
+}
+function Select(schema, baseUri, $ref) {
+    if ((0, index_2.IsUri)(baseUri)) {
+        const [base, ref] = [new URL(baseUri), new URL($ref, baseUri)];
+        const matched = base.pathname === ref.pathname;
+        const withHash = IsHash(ref.hash);
+        if (matched && !withHash) {
+            return schema;
+        }
+    }
+    if (IsHashPointer($ref)) {
+        const target = index_3.Pointer.Get(schema, $ref.slice(1));
+        if (S.IsSchemaLike(target))
+            return target;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Traversal
+// ------------------------------------------------------------------
+function FromObject(schema, baseUrl, ref) {
+    // ----------------------------------------------------------------
+    // TypeBox: Fast TCyclic Deref
+    // ----------------------------------------------------------------
+    if (S.IsDefs(schema) && index_1.Guard.HasPropertyKey(schema.$defs, ref.$ref)) {
+        return schema.$defs[ref.$ref];
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    const rebase = Rebase(baseUrl, schema);
+    const target = Select(schema, rebase, ref.$ref);
+    if (S.IsSchemaLike(target))
+        return target;
+    // Keep searching ...
+    return Object.values(schema).reduce((result, subschema) => result || FromValue(subschema, rebase, ref), undefined);
+}
+function FromArray(schema, baseUri, ref) {
+    return schema.reduce((result, value) => result || FromValue(value, baseUri, ref), undefined);
+}
+function FromValue(schema, base, ref) {
+    return ((index_1.Guard.IsObject(schema) && FromObject(schema, base, ref)) ||
+        (index_1.Guard.IsArray(schema) && FromArray(schema, base, ref)) ||
+        undefined);
+}
+// ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+/** Deferences a schema with the given Ref */
+function Deref(schema, ref) {
+    return FromValue(schema, '', ref);
+}

package/build/cjs/schema/deref/index.d.ts

@@ -0,0 +1 @@
+export { Deref } from './deref';

package/build/cjs/schema/deref/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deref = void 0;
+var deref_1 = require("./deref");
+Object.defineProperty(exports, "Deref", { enumerable: true, get: function () { return deref_1.Deref; } });

package/build/cjs/schema/engine/_context.d.ts

@@ -0,0 +1,42 @@
+import * as S from '../types/index';
+import type { TValidationError } from '../../error/index';
+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);
+    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);
+    UseUnevaluated(): boolean;
+    AddIndex(index: string): string;
+    AddKey(key: string): string;
+    Clone(): string;
+    Merge(results: string): string;
+}
+export declare class CheckContext extends BaseContext {
+    private readonly indices;
+    private readonly keys;
+    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike);
+    AddIndex(index: number): true;
+    AddKey(key: string): true;
+    GetIndices(): Set<number>;
+    GetKeys(): Set<string>;
+    Clone(): CheckContext;
+    Merge(results: CheckContext[]): true;
+}
+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);
+    AddError(error: TValidationError): false;
+}
+export declare class AccumulatedErrorContext extends ErrorContext {
+    private readonly errors;
+    constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike);
+    AddError(error: TValidationError): false;
+    GetErrors(): TValidationError[];
+}

package/build/cjs/schema/engine/_context.js

@@ -0,0 +1,130 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccumulatedErrorContext = exports.ErrorContext = exports.CheckContext = exports.BuildContext = exports.BaseContext = void 0;
+exports.HasUnevaluated = HasUnevaluated;
+const S = require("../types/index");
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// HasUnevaluated
+// ------------------------------------------------------------------
+function HasUnevaluatedFromObject(value) {
+    return (S.IsUnevaluatedItems(value)
+        || S.IsUnevaluatedProperties(value)
+        || index_1.Guard.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
+}
+function HasUnevaluatedFromArray(value) {
+    return value.some(value => HasUnevaluatedFromUnknown(value));
+}
+function HasUnevaluatedFromUnknown(value) {
+    return (index_1.Guard.IsArray(value) ? HasUnevaluatedFromArray(value) :
+        index_1.Guard.IsObject(value) ? HasUnevaluatedFromObject(value) :
+            false);
+}
+function HasUnevaluated(context, schema) {
+    return HasUnevaluatedFromUnknown(schema) || index_1.Guard.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
+}
+// ------------------------------------------------------------------
+// BaseContext
+// ------------------------------------------------------------------
+class BaseContext {
+    constructor(context, schema) {
+        this.context = context;
+        this.schema = schema;
+    }
+    GetContext() {
+        return this.context;
+    }
+    GetSchema() {
+        return this.schema;
+    }
+}
+exports.BaseContext = BaseContext;
+// ------------------------------------------------------------------
+// BuildContext
+// ------------------------------------------------------------------
+class BuildContext extends BaseContext {
+    constructor(context, schema, hasUnevaluated) {
+        super(context, schema);
+        this.hasUnevaluated = hasUnevaluated;
+    }
+    UseUnevaluated() {
+        return this.hasUnevaluated;
+    }
+    AddIndex(index) {
+        return index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'AddIndex'), [index]);
+    }
+    AddKey(key) {
+        return index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'AddKey'), [key]);
+    }
+    Clone() {
+        return index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'Clone'), []);
+    }
+    Merge(results) {
+        return index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'Merge'), [results]);
+    }
+}
+exports.BuildContext = BuildContext;
+// ------------------------------------------------------------------
+// CheckContext
+// ------------------------------------------------------------------
+class CheckContext extends BaseContext {
+    constructor(context, schema) {
+        super(context, schema);
+        this.indices = new Set();
+        this.keys = new Set();
+    }
+    AddIndex(index) {
+        this.indices.add(index);
+        return true;
+    }
+    AddKey(key) {
+        this.keys.add(key);
+        return true;
+    }
+    GetIndices() {
+        return this.indices;
+    }
+    GetKeys() {
+        return this.keys;
+    }
+    Clone() {
+        return new CheckContext(this.context, this.schema);
+    }
+    Merge(results) {
+        for (const context of results) {
+            context.indices.forEach(value => this.indices.add(value));
+            context.keys.forEach(value => this.keys.add(value));
+        }
+        return true;
+    }
+}
+exports.CheckContext = CheckContext;
+class ErrorContext extends CheckContext {
+    constructor(context, schema, callback) {
+        super(context, schema);
+        this.callback = callback;
+    }
+    AddError(error) {
+        this.callback(error);
+        return false;
+    }
+}
+exports.ErrorContext = ErrorContext;
+// ------------------------------------------------------------------
+// AccumulatedErrorContext
+// ------------------------------------------------------------------
+class AccumulatedErrorContext extends ErrorContext {
+    constructor(context, schema) {
+        super(context, schema, error => this.errors.push(error));
+        this.errors = [];
+    }
+    AddError(error) {
+        this.errors.push(error);
+        return false;
+    }
+    GetErrors() {
+        return this.errors;
+    }
+}
+exports.AccumulatedErrorContext = AccumulatedErrorContext;

package/build/cjs/schema/engine/_exact_optional.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsExactOptional = IsExactOptional;
+exports.InexactOptionalBuild = InexactOptionalBuild;
+exports.InexactOptionalCheck = InexactOptionalCheck;
+const index_1 = require("../../system/settings/index");
+const index_2 = require("../../guard/index");
+// ------------------------------------------------------------------
+// IsExactOptional
+// ------------------------------------------------------------------
+function IsExactOptional(required, key) {
+    return required.includes(key) || index_1.Settings.Get().exactOptionalPropertyTypes;
+}
+// ------------------------------------------------------------------
+// ExactOptionalBuild
+// ------------------------------------------------------------------
+function InexactOptionalBuild(value, key) {
+    return index_2.EmitGuard.IsUndefined(index_2.EmitGuard.Member(value, key));
+}
+// ------------------------------------------------------------------
+// ExactOptionalCheck
+// ------------------------------------------------------------------
+function InexactOptionalCheck(value, key) {
+    return index_2.Guard.IsUndefined(value[key]);
+}

package/build/cjs/schema/engine/_externals.js

@@ -0,0 +1,39 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetExternal = ResetExternal;
+exports.CreateExternalVariable = CreateExternalVariable;
+exports.GetExternal = GetExternal;
+const identifier = 'external_';
+let resetCount = 0;
+const state = {
+    identifier: `${identifier}${resetCount}`,
+    variables: []
+};
+// ------------------------------------------------------------------
+// ResetExternals
+//
+// Each reset results in a new external group identifier. This is done 
+// to prevent variable name overlap when generating and evaluating
+// multiple types in the same scope.
+//
+// ------------------------------------------------------------------
+function ResetExternal() {
+    state.identifier = `${identifier}${resetCount}`;
+    state.variables = [];
+    resetCount += 1;
+}
+// ------------------------------------------------------------------
+// CreateExternalVariable
+// ------------------------------------------------------------------
+function CreateExternalVariable(value) {
+    const call = `${state.identifier}[${state.variables.length}]`;
+    state.variables.push(value);
+    return call;
+}
+// ------------------------------------------------------------------
+// GetExternals
+// ------------------------------------------------------------------
+function GetExternal() {
+    return state;
+}

package/build/cjs/schema/engine/_functions.d.ts

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

package/build/cjs/schema/engine/_functions.js

@@ -0,0 +1,51 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetFunctions = ResetFunctions;
+exports.GetFunctions = GetFunctions;
+exports.CreateFunction = CreateFunction;
+const index_1 = require("../../system/hashing/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("./schema");
+const functions = new Map();
+// ------------------------------------------------------------------
+// CreateCallExpression
+// ------------------------------------------------------------------
+function CreateCallExpression(context, schema, hash, value) {
+    return context.UseUnevaluated()
+        ? index_2.EmitGuard.Call(`check_${hash}`, ['context', value])
+        : index_2.EmitGuard.Call(`check_${hash}`, [value]);
+}
+// ------------------------------------------------------------------
+// CreateFunctionExpression
+// ------------------------------------------------------------------
+function CreateFunctionExpression(context, schema, hash) {
+    const expression = (0, schema_1.BuildSchema)(context, schema, 'value');
+    return context.UseUnevaluated()
+        ? index_2.EmitGuard.ConstDeclaration(`check_${hash}`, index_2.EmitGuard.ArrowFunction(['context', 'value'], expression))
+        : index_2.EmitGuard.ConstDeclaration(`check_${hash}`, index_2.EmitGuard.ArrowFunction(['value'], expression));
+}
+// ------------------------------------------------------------------
+// ResetFunctions
+// ------------------------------------------------------------------
+function ResetFunctions() {
+    functions.clear();
+}
+// ------------------------------------------------------------------
+// GetFunctions
+// ------------------------------------------------------------------
+function GetFunctions() {
+    return [...functions.values()];
+}
+// ------------------------------------------------------------------
+// CreateFunction
+// ------------------------------------------------------------------
+function CreateFunction(context, schema, value) {
+    const hash = index_1.Hashing.Hash(schema);
+    const call = CreateCallExpression(context, schema, hash, value);
+    if (functions.has(hash))
+        return call;
+    functions.set(hash, '');
+    functions.set(hash, CreateFunctionExpression(context, schema, hash));
+    return call;
+}

package/build/cjs/schema/engine/_guard.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildGuard(context: BuildContext, schema: S.XGuard, value: string): string;
+export declare function CheckGuard(context: CheckContext, schema: S.XGuard, value: unknown): boolean;
+export declare function ErrorGuard(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XGuard, value: unknown): boolean;

package/build/cjs/schema/engine/_guard.js

@@ -0,0 +1,31 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildGuard = BuildGuard;
+exports.CheckGuard = CheckGuard;
+exports.ErrorGuard = ErrorGuard;
+const V = require("./_externals");
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildGuard(context, schema, value) {
+    return index_1.EmitGuard.Call(index_1.EmitGuard.Member(index_1.EmitGuard.Member(V.CreateExternalVariable(schema), '~guard'), 'check'), [value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckGuard(context, schema, value) {
+    return schema['~guard'].check(value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorGuard(context, schemaPath, instancePath, schema, value) {
+    return schema['~guard'].check(value) || context.AddError({
+        keyword: '~guard',
+        schemaPath,
+        instancePath,
+        params: { errors: schema['~guard'].errors(value) },
+    });
+}

package/build/cjs/schema/engine/_reducer.d.ts

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

package/build/cjs/schema/engine/_reducer.js

@@ -0,0 +1,48 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reducer = Reducer;
+const index_1 = require("../../guard/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Reducer
+//
+// This function is used to generate an reducer evaluation context 
+// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
+// is required from 2019-09 onwards to gather evaluated keys and indices
+// for the unevaluatedItems and unevaluatedProperties keywords.
+//
+// ------------------------------------------------------------------
+//
+// const context = new Context() // exterior
+//
+// (() => {
+//   const results = []
+//
+//   const context_0 = context.Clone()
+//   const context_1 = context.Clone()
+//   const context_2 = context.Clone()
+//   const context_3 = context.Clone()
+//   
+//   const condition_0 = ((context) => <subschema>)(context_0)
+//   const condition_1 = ((context) => <subschema>)(context_1)
+//   const condition_2 = ((context) => <subschema>)(context_2)
+//   const condition_3 = ((context) => <subschema>)(context_3)
+// 
+//   if(condition_0) results.push(context_0)
+//   if(condition_1) results.push(context_1)
+//   if(condition_2) results.push(context_2)
+//   if(condition_3) results.push(context_3)
+//
+//   return <check> && context.Merge(results)
+// })()
+//
+// ------------------------------------------------------------------
+function Reducer(context, schemas, value, check) {
+    const results = index_1.EmitGuard.ConstDeclaration('results', '[]');
+    const context_n = schemas.map((_schema, index) => index_1.EmitGuard.ConstDeclaration(`context_${index}`, context.Clone()));
+    const condition_n = schemas.map((schema, index) => index_1.EmitGuard.ConstDeclaration(`condition_${index}`, index_1.EmitGuard.Call(index_1.EmitGuard.ArrowFunction(['context'], (0, schema_1.BuildSchema)(context, schema, value)), [`context_${index}`])));
+    const checks = schemas.map((_schema, index) => index_1.EmitGuard.If(`condition_${index}`, index_1.EmitGuard.Call(index_1.EmitGuard.Member('results', 'push'), [`context_${index}`])));
+    const returns = index_1.EmitGuard.Return(index_1.EmitGuard.And(check, context.Merge('results')));
+    return index_1.EmitGuard.Call(index_1.EmitGuard.ArrowFunction([], index_1.EmitGuard.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
+}

package/build/cjs/schema/engine/_refine.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildRefine(context: BuildContext, schema: S.XRefine, value: string): string;
+export declare function CheckRefine(context: CheckContext, schema: S.XRefine, value: unknown): boolean;
+export declare function ErrorRefine(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;

package/build/cjs/schema/engine/_refine.js

@@ -0,0 +1,34 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildRefine = BuildRefine;
+exports.CheckRefine = CheckRefine;
+exports.ErrorRefine = ErrorRefine;
+const V = require("./_externals");
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildRefine(context, schema, value) {
+    const refinements = V.CreateExternalVariable(schema['~refine'].map((refinement) => refinement));
+    return index_1.EmitGuard.Every(refinements, index_1.EmitGuard.Constant(0), ['refinement', '_'], index_1.EmitGuard.Call(index_1.EmitGuard.Member('refinement', 'refine'), [value]));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckRefine(context, schema, value) {
+    return index_1.Guard.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorRefine(context, schemaPath, instancePath, schema, value) {
+    return index_1.Guard.EveryAll(schema['~refine'], 0, (refinement, index) => {
+        return refinement.refine(value) || context.AddError({
+            keyword: '~refine',
+            schemaPath,
+            instancePath,
+            params: { index, message: refinement.message },
+        });
+    });
+}

package/build/cjs/schema/engine/additionalItems.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildAdditionalItems(context: BuildContext, schema: S.XAdditionalItems, value: string): string;
+export declare function CheckAdditionalItems(context: CheckContext, schema: S.XAdditionalItems, value: unknown[]): boolean;
+export declare function ErrorAdditionalItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalItems, value: unknown[]): boolean;

package/build/cjs/schema/engine/additionalItems.js

@@ -0,0 +1,53 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildAdditionalItems = BuildAdditionalItems;
+exports.CheckAdditionalItems = CheckAdditionalItems;
+exports.ErrorAdditionalItems = ErrorAdditionalItems;
+const S = require("../types/index");
+const index_1 = require("../../guard/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return S.IsItems(schema) && index_1.Guard.IsArray(schema.items);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildAdditionalItems(context, schema, value) {
+    if (!IsValid(schema))
+        return index_1.EmitGuard.Constant(true);
+    const isSchema = (0, schema_1.BuildSchema)(context, schema.additionalItems, 'element');
+    const isLength = index_1.EmitGuard.IsLessThan('index', index_1.EmitGuard.Constant(schema.items.length));
+    const addIndex = context.AddIndex('index');
+    const guarded = context.UseUnevaluated() ? index_1.EmitGuard.Or(isLength, index_1.EmitGuard.And(isSchema, addIndex)) : index_1.EmitGuard.Or(isLength, isSchema);
+    return index_1.EmitGuard.Call(index_1.EmitGuard.Member(value, 'every'), [index_1.EmitGuard.ArrowFunction(['element', 'index'], guarded)]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckAdditionalItems(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((element, index) => {
+        return index_1.Guard.IsLessThan(index, schema.items.length)
+            || ((0, schema_1.CheckSchema)(context, schema.additionalItems, element) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorAdditionalItems(context, schemaPath, instancePath, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((element, index) => {
+        const nextSchemaPath = `${schemaPath}/additionalItems`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return index_1.Guard.IsLessThan(index, schema.items.length) ||
+            ((0, schema_1.ErrorSchema)(context, nextSchemaPath, nextInstancePath, schema.additionalItems, element) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}

package/build/cjs/schema/engine/additionalProperties.d.ts

@@ -0,0 +1,8 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function CanAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties, value: string): schema is S.XAdditionalProperties & S.XRequired;
+export declare function BuildAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
+export declare function BuildAdditionalPropertiesStandard(context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function BuildAdditionalProperties(context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function CheckAdditionalProperties(context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorAdditionalProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;