@sng2c/pi-the-giver 0.1.0 → 0.1.1

package/node_modules/typebox/build/schema/engine/index.mjs

@@ -0,0 +1,55 @@
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+export * from './_context.mjs';
+export * from './_externals.mjs';
+export * from './_guard.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_refine.mjs';
+export * from './_stack.mjs';
+// ------------------------------------------------------------------
+// Schematics
+// ------------------------------------------------------------------
+export * from './additionalItems.mjs';
+export * from './additionalProperties.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 './dependentRequired.mjs';
+export * from './dependentSchemas.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 './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './maximum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './minimum.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 './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './type.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';
+export * from './uniqueItems.mjs';

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

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

package/node_modules/typebox/build/schema/engine/items.mjs

@@ -0,0 +1,68 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
+// ------------------------------------------------------------------
+// ItemsSized
+// ------------------------------------------------------------------
+function BuildItemsSized(stack, context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
+        const isSchema = BuildSchemaPushStack(stack, 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(stack, context, schema, value) {
+    return G.Every(schema.items, 0, (schema, index) => {
+        return G.IsLessEqualThan(value.length, index)
+            || (CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index));
+    });
+}
+function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(schema.items, 0, (schema, index) => {
+        const nextSchemaPath = `${schemaPath}/items/${index}`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsLessEqualThan(value.length, index)
+            || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+    });
+}
+// ------------------------------------------------------------------
+// ItemsUnsized
+// ------------------------------------------------------------------
+function BuildItemsUnsized(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    const addIndex = context.AddIndex('index');
+    const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
+    return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
+}
+function CheckItemsUnsized(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.Every(value, offset, (element, index) => {
+        return CheckSchemaPushStack(stack, context, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+function ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.EveryAll(value, offset, (element, index) => {
+        const nextSchemaPath = `${schemaPath}/items`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Items
+// ------------------------------------------------------------------
+export function BuildItems(stack, context, schema, value) {
+    return Schema.IsItemsSized(schema) ? BuildItemsSized(stack, context, schema, value) : BuildItemsUnsized(stack, context, schema, value);
+}
+export function CheckItems(stack, context, schema, value) {
+    return Schema.IsItemsSized(schema) ? CheckItemsSized(stack, context, schema, value) : CheckItemsUnsized(stack, context, schema, value);
+}
+export function ErrorItems(stack, context, schemaPath, instancePath, schema, value) {
+    return Schema.IsItemsSized(schema) ? ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) : ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value);
+}

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

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

package/node_modules/typebox/build/schema/engine/maxContains.mjs

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

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(schema.maxItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxItems(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(value.length, schema.maxItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxItems(stack, context, schema, value) || context.AddError({
+        keyword: 'maxItems',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxItems }
+    });
+}

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsMaxLength(value, E.Constant(schema.maxLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxLength(_stack, _context, schema, value) {
+    return G.IsMaxLength(value, schema.maxLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxLength(stack, context, schema, value) || context.AddError({
+        keyword: 'maxLength',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxLength }
+    });
+}

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.maxProperties));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxProperties(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(G.Keys(value).length, schema.maxProperties);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
+        keyword: 'maxProperties',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxProperties },
+    });
+}

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(value, E.Constant(schema.maximum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaximum(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(value, schema.maximum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaximum(stack, context, schema, value) || context.AddError({
+        keyword: 'maximum',
+        schemaPath,
+        instancePath,
+        params: { comparison: '<=', limit: schema.maximum }
+    });
+}

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

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

package/node_modules/typebox/build/schema/engine/minContains.mjs

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

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsGreaterEqualThan(E.Member(value, 'length'), E.Constant(schema.minItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinItems(_stack, _context, schema, value) {
+    return G.IsGreaterEqualThan(value.length, schema.minItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinItems(stack, context, schema, value) || context.AddError({
+        keyword: 'minItems',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.minItems }
+    });
+}

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsMinLength(value, E.Constant(schema.minLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinLength(_stack, _context, schema, value) {
+    return G.IsMinLength(value, schema.minLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinLength(stack, context, schema, value) || context.AddError({
+        keyword: 'minLength',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.minLength }
+    });
+}

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

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

package/node_modules/typebox/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(_stack, _context, schema, value) {
+    return E.IsGreaterEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.minProperties));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinProperties(_stack, _context, schema, value) {
+    return G.IsGreaterEqualThan(G.Keys(value).length, schema.minProperties);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinProperties(stack, context, schema, value) || context.AddError({
+        keyword: 'minProperties',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.minProperties },
+    });
+}

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

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

package/node_modules/typebox/build/schema/engine/minimum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinimum(_stack, _context, schema, value) {
+    return E.IsGreaterEqualThan(value, E.Constant(schema.minimum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinimum(_stack, _context, schema, value) {
+    return G.IsGreaterEqualThan(value, schema.minimum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinimum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinimum(stack, context, schema, value) || context.AddError({
+        keyword: 'minimum',
+        schemaPath,
+        instancePath,
+        params: { comparison: '>=', limit: schema.minimum }
+    });
+}

package/node_modules/typebox/build/schema/engine/multipleOf.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMultipleOf(_stack: Stack, _context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
+export declare function CheckMultipleOf(_stack: Stack, _context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
+export declare function ErrorMultipleOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMultipleOf, value: number | bigint): boolean;

package/node_modules/typebox/build/schema/engine/multipleOf.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMultipleOf(_stack, _context, schema, value) {
+    return E.MultipleOf(value, E.Constant(schema.multipleOf));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMultipleOf(_stack, _context, schema, value) {
+    return G.IsMultipleOf(value, schema.multipleOf);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMultipleOf(stack, context, schema, value) || context.AddError({
+        keyword: 'multipleOf',
+        schemaPath,
+        instancePath,
+        params: { multipleOf: schema.multipleOf }
+    });
+}

package/node_modules/typebox/build/schema/engine/not.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildNot(stack: Stack, context: BuildContext, schema: Schema.XNot, value: string): string;
+export declare function CheckNot(stack: Stack, context: CheckContext, schema: Schema.XNot, value: unknown): boolean;
+export declare function ErrorNot(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XNot, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/not.mjs

@@ -0,0 +1,37 @@
+// deno-fmt-ignore-file
+import { CheckContext } from './_context.mjs';
+import { Reducer } from './_reducer.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildNotUnevaluated(stack, context, schema, value) {
+    return Reducer(stack, context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
+}
+function BuildNotFast(stack, context, schema, value) {
+    return E.Not(BuildSchema(stack, context, schema.not, value));
+}
+export function BuildNot(stack, context, schema, value) {
+    return context.UseUnevaluated() ? BuildNotUnevaluated(stack, context, schema, value) : BuildNotFast(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckNot(stack, context, schema, value) {
+    const nextContext = new CheckContext();
+    const isSchema = !CheckSchema(stack, nextContext, schema.not, value);
+    const isNot = isSchema && context.Merge([nextContext]);
+    return isNot;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorNot(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckNot(stack, context, schema, value) || context.AddError({
+        keyword: 'not',
+        schemaPath,
+        instancePath,
+        params: {},
+    });
+}

package/node_modules/typebox/build/schema/engine/oneOf.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildOneOf(stack: Stack, context: BuildContext, schema: Schema.XOneOf, value: string): string;
+export declare function CheckOneOf(stack: Stack, context: CheckContext, schema: Schema.XOneOf, value: unknown): boolean;
+export declare function ErrorOneOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XOneOf, value: unknown): boolean;