typebox 0.0.1 → 1.0.0-rc

package/build/schema/engine/exclusiveMinimum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildExclusiveMinimum(context, schema, value) {
+    return E.IsGreaterThan(value, E.Constant(schema.exclusiveMinimum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckExclusiveMinimum(context, schema, value) {
+    return G.IsGreaterThan(value, schema.exclusiveMinimum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorExclusiveMinimum(context, schemaPath, instancePath, schema, value) {
+    return CheckExclusiveMinimum(context, schema, value) || context.AddError({
+        keyword: 'exclusiveMinimum',
+        schemaPath: `${schemaPath}/exclusiveMinimum`,
+        instancePath,
+        params: { comparison: '>', limit: schema.exclusiveMinimum }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildFormat(context: BuildContext, schema: S.XFormat, value: string): string;
+export declare function CheckFormat(context: CheckContext, schema: S.XFormat, value: string): boolean;
+export declare function ErrorFormat(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XFormat, value: string): boolean;

package/build/schema/engine/format.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { Format } from '../../format/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildFormat(context, schema, value) {
+    return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckFormat(context, schema, value) {
+    return Format.Test(schema.format, value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorFormat(context, schemaPath, instancePath, schema, value) {
+    return CheckFormat(context, schema, value) || context.AddError({
+        keyword: 'format',
+        schemaPath: `${schemaPath}/format`,
+        instancePath,
+        params: { format: schema.format },
+    });
+}

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

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

package/build/schema/engine/if.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildIf(context, schema, value) {
+    const thenSchema = S.IsThen(schema) ? schema.then : true;
+    const elseSchema = S.IsElse(schema) ? schema.else : true;
+    return E.Ternary(BuildSchema(context, schema.if, value), BuildSchema(context, thenSchema, value), BuildSchema(context, elseSchema, value));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckIf(context, schema, value) {
+    const thenSchema = S.IsThen(schema) ? schema.then : true;
+    const elseSchema = S.IsElse(schema) ? schema.else : true;
+    return CheckSchema(context, schema.if, value)
+        ? CheckSchema(context, thenSchema, value)
+        : CheckSchema(context, elseSchema, value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorIf(context, schemaPath, instancePath, schema, value) {
+    const thenSchema = S.IsThen(schema) ? schema.then : true;
+    const elseSchema = S.IsElse(schema) ? schema.else : true;
+    const trueContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+    const isIf = ErrorSchema(trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
+        ? ErrorSchema(trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
+            keyword: 'if',
+            schemaPath: `${schemaPath}/if`,
+            instancePath,
+            params: { failingKeyword: 'then' },
+        })
+        : ErrorSchema(context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
+            keyword: 'if',
+            schemaPath: `${schemaPath}/if`,
+            instancePath,
+            params: { failingKeyword: 'else' },
+        });
+    if (isIf)
+        context.Merge([trueContext]);
+    return isIf;
+}

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

@@ -0,0 +1,47 @@
+export * from './_context.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_externals.mjs';
+export * from './_refine.mjs';
+export * from './_standard.mjs';
+export * from './additionalProperties.mjs';
+export * from './additionalItems.mjs';
+export * from './allOf.mjs';
+export * from './anyOf.mjs';
+export * from './boolean.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './dependencies.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maximum.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './minimum.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './type.mjs';
+export * from './uniqueItems.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './minContains.mjs';
+export * from './maxContains.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';
+export * from './schema.mjs';

package/build/schema/engine/index.mjs

@@ -0,0 +1,53 @@
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+export * from './_context.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_externals.mjs';
+// ------------------------------------------------------------------
+// Schematics
+// ------------------------------------------------------------------
+export * from './_refine.mjs';
+export * from './_standard.mjs';
+export * from './additionalProperties.mjs';
+export * from './additionalItems.mjs';
+export * from './allOf.mjs';
+export * from './anyOf.mjs';
+export * from './boolean.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './dependencies.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maximum.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './minimum.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './type.mjs';
+export * from './uniqueItems.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './minContains.mjs';
+export * from './maxContains.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';
+export * from './schema.mjs';

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

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

package/build/schema/engine/items.mjs

@@ -0,0 +1,65 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// ItemsSized
+// ------------------------------------------------------------------
+function BuildItemsSized(context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsGreaterEqualThan(E.Constant(index), E.Member(value, 'length'));
+        const isSchema = BuildSchema(context, schema, `${value}[${index}]`);
+        const addIndex = context.AddIndex(E.Constant(index));
+        const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
+        return E.Or(isLength, guarded);
+    }));
+}
+function CheckItemsSized(context, schema, value) {
+    return G.Every(schema.items, (schema, index) => {
+        return G.IsGreaterEqualThan(index, value.length)
+            || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
+    });
+}
+function ErrorItemsSized(context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(schema.items, (schema, index) => {
+        const nextSchemaPath = `${schemaPath}/items/${index}`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsGreaterEqualThan(index, value.length)
+            || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+    });
+}
+// ------------------------------------------------------------------
+// ItemsUnsized
+// ------------------------------------------------------------------
+function BuildItemsUnsized(context, schema, value) {
+    const isSchema = BuildSchema(context, schema.items, 'element');
+    const addIndex = context.AddIndex('index');
+    const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
+    return E.Call(E.Member(value, 'every'), [E.ArrowFunction(['element', 'index'], guarded)]);
+}
+function CheckItemsUnsized(context, schema, value) {
+    return G.Every(value, (element, index) => {
+        return CheckSchema(context, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+function ErrorItemsUnsized(context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(value, (element, index) => {
+        const nextSchemaPath = `${schemaPath}/items`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return ErrorSchema(context, nextSchemaPath, nextInstancePath, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Items
+// ------------------------------------------------------------------
+export function BuildItems(context, schema, value) {
+    return S.IsItemsSized(schema) ? BuildItemsSized(context, schema, value) : BuildItemsUnsized(context, schema, value);
+}
+export function CheckItems(context, schema, value) {
+    return S.IsItemsSized(schema) ? CheckItemsSized(context, schema, value) : CheckItemsUnsized(context, schema, value);
+}
+export function ErrorItems(context, schemaPath, instancePath, schema, value) {
+    return S.IsItemsSized(schema) ? ErrorItemsSized(context, schemaPath, instancePath, schema, value) : ErrorItemsUnsized(context, schemaPath, instancePath, schema, value);
+}

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

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

package/build/schema/engine/maxContains.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return S.IsContains(schema);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxContains(context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction(['result', 'value'], E.Ternary(BuildSchema(context, schema.contains, 'value'), E.PrefixIncrement('result'), 'result')), E.Constant(0)]);
+    return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxContains(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const count = value.reduce((result, value) => CheckSchema(context, schema.contains, value) ? ++result : result, 0);
+    return G.IsLessEqualThan(count, schema.maxContains);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxContains(context, schemaPath, instancePath, schema, value) {
+    const minContains = S.IsMinContains(schema) ? schema.minContains : 1;
+    return CheckMaxContains(context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath: `${schemaPath}/contains`,
+        instancePath,
+        params: { minContains, maxContains: schema.maxContains },
+    });
+}

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

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

package/build/schema/engine/maxItems.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxItems(context, schema, value) {
+    return E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(schema.maxItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxItems(context, schema, value) {
+    return G.IsLessEqualThan(value.length, schema.maxItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxItems(context, schemaPath, instancePath, schema, value) {
+    return CheckMaxItems(context, schema, value) || context.AddError({
+        keyword: 'maxItems',
+        schemaPath: `${schemaPath}/maxItems`,
+        instancePath,
+        params: { limit: schema.maxItems }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxLength(context: BuildContext, schema: S.XMaxLength, value: string): string;
+export declare function CheckMaxLength(context: CheckContext, schema: S.XMaxLength, value: string): boolean;
+export declare function ErrorMaxLength(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMaxLength, value: string): boolean;

package/build/schema/engine/maxLength.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxLength(context, schema, value) {
+    return E.IsLessEqualThan(E.StringGraphemeCount(value), E.Constant(schema.maxLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxLength(context, schema, value) {
+    return G.IsLessEqualThan(G.StringGraphemeCount(value), schema.maxLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxLength(context, schemaPath, instancePath, schema, value) {
+    return CheckMaxLength(context, schema, value) || context.AddError({
+        keyword: 'maxLength',
+        schemaPath: `${schemaPath}/maxLength`,
+        instancePath,
+        params: { limit: schema.maxLength }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxProperties(context: BuildContext, schema: S.XMaxProperties, value: string): string;
+export declare function CheckMaxProperties(context: CheckContext, schema: S.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMaxProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/maxProperties.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxProperties(context, schema, value) {
+    return E.IsLessEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.maxProperties));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxProperties(context, schema, value) {
+    return G.IsLessEqualThan(G.Keys(value).length, schema.maxProperties);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function ErrorMaxProperties(context, schemaPath, instancePath, schema, value) {
+    return CheckMaxProperties(context, schema, value) || context.AddError({
+        keyword: 'maxProperties',
+        schemaPath: `${schemaPath}/maxProperties`,
+        instancePath,
+        params: { limit: schema.maxProperties },
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaximum(context: BuildContext, schema: S.XMaximum, value: string): string;
+export declare function CheckMaximum(context: CheckContext, schema: S.XMaximum, value: number | bigint): boolean;
+export declare function ErrorMaximum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMaximum, value: number | bigint): boolean;

package/build/schema/engine/maximum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaximum(context, schema, value) {
+    return E.IsLessEqualThan(value, E.Constant(schema.maximum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaximum(context, schema, value) {
+    return G.IsLessEqualThan(value, schema.maximum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaximum(context, schemaPath, instancePath, schema, value) {
+    return CheckMaximum(context, schema, value) || context.AddError({
+        keyword: 'maximum',
+        schemaPath: `${schemaPath}/maximum`,
+        instancePath,
+        params: { comparison: '<=', limit: schema.maximum }
+    });
+}

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

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

package/build/schema/engine/minContains.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return S.IsContains(schema);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinContains(context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction(['result', 'value'], E.Ternary(BuildSchema(context, schema.contains, 'value'), E.PrefixIncrement('result'), 'result')), E.Constant(0)]);
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinContains(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const count = value.reduce((result, value) => CheckSchema(context, schema.contains, value) ? ++result : result, 0);
+    return G.IsGreaterEqualThan(count, schema.minContains);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinContains(context, schemaPath, instancePath, schema, value) {
+    return CheckMinContains(context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath: `${schemaPath}/contains`,
+        instancePath,
+        params: { minContains: schema.minContains }
+    });
+}

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

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

package/build/schema/engine/minItems.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinItems(context, schema, value) {
+    return E.IsGreaterEqualThan(E.Member(value, 'length'), E.Constant(schema.minItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinItems(context, schema, value) {
+    return G.IsGreaterEqualThan(value.length, schema.minItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinItems(context, schemaPath, instancePath, schema, value) {
+    return CheckMinItems(context, schema, value) || context.AddError({
+        keyword: 'minItems',
+        schemaPath: `${schemaPath}/minItems`,
+        instancePath,
+        params: { limit: schema.minItems }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMinLength(context: BuildContext, schema: S.XMinLength, value: string): string;
+export declare function CheckMinLength(context: CheckContext, schema: S.XMinLength, value: string): boolean;
+export declare function ErrorMinLength(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinLength, value: string): boolean;

package/build/schema/engine/minLength.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinLength(context, schema, value) {
+    return E.IsGreaterEqualThan(E.StringGraphemeCount(value), E.Constant(schema.minLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinLength(context, schema, value) {
+    return G.IsGreaterEqualThan(G.StringGraphemeCount(value), schema.minLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinLength(context, schemaPath, instancePath, schema, value) {
+    return CheckMinLength(context, schema, value) || context.AddError({
+        keyword: 'minLength',
+        schemaPath: `${schemaPath}/minLength`,
+        instancePath,
+        params: { limit: schema.minLength }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMinProperties(context: BuildContext, schema: S.XMinProperties, value: string): string;
+export declare function CheckMinProperties(context: CheckContext, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMinProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/minProperties.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinProperties(context, schema, value) {
+    return E.IsGreaterEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.minProperties));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinProperties(context, schema, value) {
+    return G.IsGreaterEqualThan(G.Keys(value).length, schema.minProperties);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinProperties(context, schemaPath, instancePath, schema, value) {
+    return CheckMinProperties(context, schema, value) || context.AddError({
+        keyword: 'minProperties',
+        schemaPath: `${schemaPath}/minProperties`,
+        instancePath,
+        params: { limit: schema.minProperties },
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMinimum(context: BuildContext, schema: S.XMinimum, value: string): string;
+export declare function CheckMinimum(context: CheckContext, schema: S.XMinimum, value: number | bigint): boolean;
+export declare function ErrorMinimum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinimum, value: number | bigint): boolean;