@yaag/cli 0.1.0

package/assets/types/typebox/build/schema/engine/dependentSchemas.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 BuildDependentSchemas(stack: Stack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
+export declare function CheckDependentSchemas(stack: Stack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentSchemas(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/dynamicRef.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 BuildDynamicRef(stack: Stack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
+export declare function CheckDynamicRef(stack: Stack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function ErrorDynamicRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/enum.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 BuildEnum(_stack: Stack, _context: BuildContext, schema: Schema.XEnum, value: string): string;
+export declare function CheckEnum(_stack: Stack, _context: CheckContext, schema: Schema.XEnum, value: unknown): boolean;
+export declare function ErrorEnum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XEnum, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/exclusiveMaximum.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 BuildExclusiveMaximum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMaximum, value: string): string;
+export declare function CheckExclusiveMaximum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMaximum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;

package/assets/types/typebox/build/schema/engine/exclusiveMinimum.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 BuildExclusiveMinimum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMinimum, value: string): string;
+export declare function CheckExclusiveMinimum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;

package/assets/types/typebox/build/schema/engine/format.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 BuildFormat(_stack: Stack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
+export declare function CheckFormat(_stack: Stack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
+export declare function ErrorFormat(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;

package/assets/types/typebox/build/schema/engine/if.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 BuildIf(stack: Stack, context: BuildContext, schema: Schema.XIf, value: string): string;
+export declare function CheckIf(stack: Stack, context: CheckContext, schema: Schema.XIf, value: unknown): boolean;
+export declare function ErrorIf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XIf, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/index.d.mts

@@ -0,0 +1,48 @@
+export * from './_context.mjs';
+export * from './_externals.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_refine.mjs';
+export * from './_stack.mjs';
+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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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/assets/types/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;

package/assets/types/typebox/build/schema/engine/pattern.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 BuildPattern(_stack: Stack, _context: BuildContext, schema: Schema.XPattern, value: string): string;
+export declare function CheckPattern(_stack: Stack, _context: CheckContext, schema: Schema.XPattern, value: string): boolean;
+export declare function ErrorPattern(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPattern, value: string): boolean;

package/assets/types/typebox/build/schema/engine/patternProperties.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 BuildPatternProperties(stack: Stack, context: BuildContext, schema: Schema.XPatternProperties, value: string): string;
+export declare function CheckPatternProperties(stack: Stack, context: CheckContext, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPatternProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/prefixItems.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 BuildPrefixItems(stack: Stack, context: BuildContext, schema: Schema.XPrefixItems, value: string): string;
+export declare function CheckPrefixItems(stack: Stack, context: CheckContext, schema: Schema.XPrefixItems, value: unknown[]): boolean;
+export declare function ErrorPrefixItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPrefixItems, value: unknown[]): boolean;

package/assets/types/typebox/build/schema/engine/properties.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 BuildProperties(stack: Stack, context: BuildContext, schema: Schema.XProperties, value: string): string;
+export declare function CheckProperties(stack: Stack, context: CheckContext, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/propertyNames.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 BuildPropertyNames(stack: Stack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
+export declare function CheckPropertyNames(stack: Stack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPropertyNames(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/recursiveRef.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 BuildRecursiveRef(stack: Stack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
+export declare function CheckRecursiveRef(stack: Stack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/ref.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 BuildRef(stack: Stack, context: BuildContext, schema: Schema.XRef, value: string): string;
+export declare function CheckRef(stack: Stack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
+export declare function ErrorRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/required.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 BuildRequired(_stack: Stack, _context: BuildContext, schema: Schema.XRequired, value: string): string;
+export declare function CheckRequired(_stack: Stack, _context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/schema.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildSchemaPushStack(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function BuildSchema(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CheckSchemaPushStack(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function CheckSchema(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchemaPushStack(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/type.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 BuildType(stack: Stack, context: BuildContext, schema: Schema.XType, value: string): string;
+export declare function CheckType(stack: Stack, context: CheckContext, schema: Schema.XType, value: unknown): boolean;
+export declare function ErrorType(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XType, value: unknown): boolean;

package/assets/types/typebox/build/schema/engine/unevaluatedItems.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 BuildUnevaluatedItems(stack: Stack, context: BuildContext, schema: Schema.XUnevaluatedItems, value: string): string;
+export declare function CheckUnevaluatedItems(stack: Stack, context: CheckContext, schema: Schema.XUnevaluatedItems, value: unknown[]): boolean;
+export declare function ErrorUnevaluatedItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUnevaluatedItems, value: unknown[]): boolean;

package/assets/types/typebox/build/schema/engine/unevaluatedProperties.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 BuildUnevaluatedProperties(stack: Stack, context: BuildContext, schema: Schema.XUnevaluatedProperties, value: string): string;
+export declare function CheckUnevaluatedProperties(stack: Stack, context: CheckContext, schema: Schema.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorUnevaluatedProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;

package/assets/types/typebox/build/schema/engine/uniqueItems.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 BuildUniqueItems(_stack: Stack, _context: BuildContext, schema: Schema.XUniqueItems, value: string): string;
+export declare function CheckUniqueItems(_stack: Stack, _context: CheckContext, schema: Schema.XUniqueItems, value: unknown[]): boolean;
+export declare function ErrorUniqueItems(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUniqueItems, value: unknown[]): boolean;

package/assets/types/typebox/build/schema/errors.d.mts

@@ -0,0 +1,6 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import * as Schema from './types/index.mjs';
+/** Checks a value and returns validation errors */
+export declare function Errors(schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
+/** Checks a value and returns validation errors */
+export declare function Errors(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];

package/assets/types/typebox/build/schema/index.d.mts

@@ -0,0 +1,3 @@
+export * from './schema.mjs';
+import * as Schema from './schema.mjs';
+export default Schema;

package/assets/types/typebox/build/schema/parse.d.mts

@@ -0,0 +1,13 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type Static } from '../type/types/static.mjs';
+import * as Schema from './types/index.mjs';
+export declare class ParseError {
+    schema: Schema.XSchema;
+    value: unknown;
+    errors: TLocalizedValidationError[];
+    constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
+}
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static<Schema>;
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static<Schema>;

package/assets/types/typebox/build/schema/pointer/index.d.mts

@@ -0,0 +1,2 @@
+export * from './pointer_get.mjs';
+export * as Pointer from './pointer.mjs';

package/assets/types/typebox/build/schema/pointer/pointer.d.mts

@@ -0,0 +1,10 @@
+/** Returns an array of path indices for the given pointer */
+export declare function Indices(pointer: string): string[];
+/** Returns true if a value exists at the current pointer */
+export declare function Has(value: unknown, pointer: string): unknown;
+/** Gets a value at the pointer, or undefined if not exists */
+export declare function Get(value: unknown, pointer: string): unknown;
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export declare function Delete(value: unknown, pointer: string): unknown;

package/assets/types/typebox/build/schema/pointer/pointer_get.d.mts

@@ -0,0 +1,9 @@
+type TEscape0<Index extends string> = Index extends `${infer Left}~0${infer Right}` ? `${Left}~${TEscape<Right>}` : Index;
+type TEscape1<Index extends string> = Index extends `${infer Left}~1${infer Right}` ? `${Left}/${TEscape<Right>}` : Index;
+type TEscape<Index extends string, Escaped0 extends string = TEscape0<Index>, Escaped1 extends string = TEscape1<Escaped0>> = Escaped1;
+type IndicesReduce<Pointer extends string, Result extends string[] = []> = (Pointer extends `${infer Left extends string}/${infer Right extends string}` ? Left extends '' ? IndicesReduce<Right, Result> : IndicesReduce<Right, [...Result, TEscape<Left>]> : [...Result, TEscape<Pointer>]);
+type TIndices<Pointer extends string, Result extends string[] = Pointer extends '' ? [] : IndicesReduce<Pointer>> = Result;
+type TResolve<Value extends unknown, Indices extends string[]> = (Indices extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Value ? TResolve<Value[Left], Right> : undefined : Value);
+/** Type Level RFC 6901 Json Pointer Resolver */
+export type XPointerGet<Value extends unknown, Pointer extends string, Indices extends string[] = TIndices<Pointer>, Result extends unknown = TResolve<Value, Indices>> = Result;
+export {};

package/assets/types/typebox/build/schema/resolve/index.d.mts

@@ -0,0 +1 @@
+export * as Resolve from './resolve.mjs';

package/assets/types/typebox/build/schema/resolve/ref.d.mts

@@ -0,0 +1,3 @@
+import * as Schema from '../types/index.mjs';
+export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
+export declare function DynamicRef(root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;

package/assets/types/typebox/build/schema/resolve/resolve.d.mts

@@ -0,0 +1 @@
+export * from './ref.mjs';

package/assets/types/typebox/build/schema/schema.d.mts

@@ -0,0 +1,10 @@
+export * from './engine/index.mjs';
+export * from './pointer/index.mjs';
+export * from './resolve/index.mjs';
+export * from './static/index.mjs';
+export * from './types/index.mjs';
+export * from './build.mjs';
+export * from './compile.mjs';
+export * from './check.mjs';
+export * from './parse.mjs';
+export * from './errors.mjs';

package/assets/types/typebox/build/schema/static/_canonical.d.mts

@@ -0,0 +1,7 @@
+type XCanonicalTuple<Value extends readonly unknown[]> = (Value extends [infer Left, ...infer Right extends unknown[]] ? [XCanonical<Left>, ...XCanonicalTuple<Right>] : []);
+type XCanonicalArray<Value extends unknown, Result extends unknown[] = XCanonical<Value>[]> = Result;
+type XCanonicalObject<Value extends object, Result extends Record<PropertyKey, unknown> = {
+    -readonly [Key in keyof Value]: XCanonical<Value[Key]>;
+}> = Result;
+export type XCanonical<Schema extends unknown> = (Schema extends readonly [...infer Schemas extends unknown[]] ? XCanonicalTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XCanonicalArray<Schema> : Schema extends object ? XCanonicalObject<Schema> : Schema);
+export {};

package/assets/types/typebox/build/schema/static/_comparer.d.mts

@@ -0,0 +1,6 @@
+type XBuildTuple<Size extends number, Tuple extends unknown[] = []> = (Tuple['length'] extends Size ? Tuple : XBuildTuple<Size, [...Tuple, unknown]>);
+export type XLessThan<Left extends number, Right extends number> = Left extends Right ? false : XBuildTuple<Left> extends [...XBuildTuple<Right>, ...infer _Rest] ? false : true;
+export type XLessThanEqual<Left extends number, Right extends number> = (Left extends Right ? true : XLessThan<Left, Right>);
+export type XGreaterThan<Left extends number, Right extends number> = (XLessThan<Right, Left>);
+export type XGreaterThanEqual<Left extends number, Right extends number> = (XLessThanEqual<Right, Left>);
+export {};

package/assets/types/typebox/build/schema/static/_elements.d.mts

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

package/assets/types/typebox/build/schema/static/additionalProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAdditionalProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Stack, Root, Schema>;
+})> = Result;

package/assets/types/typebox/build/schema/static/allOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAllOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = unknown> = (Schemas extends readonly [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAllOf<Stack, Root, Right, Result & XStaticSchema<Stack, Root, Left>> : Result);

package/assets/types/typebox/build/schema/static/anyOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAnyOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAnyOf<Stack, Root, Right, XStaticSchema<Stack, Root, Left> | Result> : Result);

package/assets/types/typebox/build/schema/static/const.d.mts

@@ -0,0 +1 @@
+export type XStaticConst<Value extends unknown> = Value;

package/assets/types/typebox/build/schema/static/enum.d.mts

@@ -0,0 +1 @@
+export type XStaticEnum<Values extends unknown[], Result extends unknown = never> = (Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XStaticEnum<Right, Left | Result> : Result);

package/assets/types/typebox/build/schema/static/if.d.mts

@@ -0,0 +1,15 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XElse } from '../types/else.mjs';
+import type { XThen } from '../types/then.mjs';
+export type XStaticIf<Stack extends string[], Root extends XSchema, Schema extends XIf, IfSchema extends XSchema, If extends unknown = XStaticSchema<Stack, Root, IfSchema>, Then extends unknown = Schema extends XThen<infer ThenSchema extends XSchema> ? XStaticSchema<Stack, Root, ThenSchema> : never, Else extends unknown = Schema extends XElse<infer ElseSchema extends XSchema> ? XStaticSchema<Stack, Root, ElseSchema> : never, IsThen extends boolean = Schema extends XThen ? true : false, IsElse extends boolean = Schema extends XElse ? true : false, Result extends unknown = ([
+    IsThen,
+    IsElse
+] extends [true, true] ? (If & Then) | Exclude<Else, If> : [
+    IsThen,
+    IsElse
+] extends [true, false] ? (If & Then) : [
+    IsThen,
+    IsElse
+] extends [false, true] ? Exclude<Else, If> : unknown)> = Result;

package/assets/types/typebox/build/schema/static/index.d.mts

@@ -0,0 +1 @@
+export type { XStatic } from './static.mjs';

package/assets/types/typebox/build/schema/static/items.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XStaticElements } from './_elements.mjs';
+type XFromSized<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[]> = (XStaticElements<Stack, Root, Schema, Items>);
+type XFromUnsized<Stack extends string[], Root extends XSchema, Schema extends XSchema> = (XStaticSchema<Stack, Root, Schema>[]);
+export type XStaticItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[] | XSchema, Result extends unknown = (Items extends XSchema[] ? XFromSized<Stack, Root, Schema, [...Items]> : Items extends XSchema ? XFromUnsized<Stack, Root, Items> : never)> = Result;
+export {};

package/assets/types/typebox/build/schema/static/oneOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticOneOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticOneOf<Stack, Root, Right, XStaticSchema<Stack, Root, Left> | Result> : Result);

package/assets/types/typebox/build/schema/static/patternProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPatternProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>, InferredProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: XStaticSchema<Stack, Root, Properties[Key]>;
+}, EvaluatedProperties extends unknown = {
+    [key: string]: InferredProperties[keyof InferredProperties];
+}> = EvaluatedProperties;

package/assets/types/typebox/build/schema/static/prefixItems.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticElements } from './_elements.mjs';
+export type XStaticPrefixItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], Result extends unknown[] = XStaticElements<Stack, Root, Schema, PrefixItems>> = Result;

package/assets/types/typebox/build/schema/static/properties.d.mts

@@ -0,0 +1,32 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XIsReadonly<Schema extends XSchema> = (Schema extends {
+    readOnly: true;
+} ? true : Schema extends {
+    '~readonly': true;
+} ? true : false);
+type XRequiredArray<Schema extends XSchema, Result extends PropertyKey[] = Schema extends XRequired<infer Keys extends string[]> ? Keys : []> = Result;
+type XReadonlyKeys<Properties extends Record<PropertyKey, XSchema>, ReadonlyProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]: unknown;
+}, Result extends PropertyKey = keyof ReadonlyProperties> = Result;
+type XRequiredKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? never : Extract<keyof Properties, RequiredArray[number]>> = Result;
+type XUnknownKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = Exclude<RequiredArray[number], keyof Properties>> = Result;
+type XOptionalKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? keyof Properties : Exclude<keyof Properties, RequiredArray[number]>> = Result;
+type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XReadonlyRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XUnknownProperties<UnknownKeys extends PropertyKey> = {
+    [Key in UnknownKeys]: unknown;
+};
+export type XStaticProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[] = XRequiredArray<Schema>, ReadonlyKeys extends PropertyKey = XReadonlyKeys<Properties>, OptionalKeys extends PropertyKey = XOptionalKeys<Properties, RequiredArray>, RequiredKeys extends PropertyKey = XRequiredKeys<Properties, RequiredArray>, UnknownKeys extends PropertyKey = XUnknownKeys<Properties, RequiredArray>, ReadonlyOptionalProperties extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Extract<OptionalKeys, ReadonlyKeys>, Properties>, ReadonlyRequiredProperties extends Record<PropertyKey, unknown> = XReadonlyRequiredProperties<Stack, Root, Extract<RequiredKeys, ReadonlyKeys>, Properties>, OptionalProperties extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Exclude<OptionalKeys, ReadonlyKeys>, Properties>, RequiredProperties extends Record<PropertyKey, unknown> = XRequiredProperties<Stack, Root, Exclude<RequiredKeys, ReadonlyKeys>, Properties>, UnknownProperties extends Record<PropertyKey, unknown> = XUnknownProperties<UnknownKeys>, Result extends Record<PropertyKey, unknown> = (ReadonlyOptionalProperties & ReadonlyRequiredProperties & OptionalProperties & RequiredProperties & UnknownProperties)> = Result;
+export {};

package/assets/types/typebox/build/schema/static/ref.d.mts

@@ -0,0 +1,8 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XPointerGet } from '../pointer/pointer_get.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XCyclicCheck<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : XCyclicCheck<Right, MaxLength, [...Buffer, Left]> : true);
+type XCyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? XCyclicCheck<Stack, 2> : true);
+type XNormal<Pointer extends string, Result extends string = (Pointer extends `#${infer Rest extends string}` ? Rest : Pointer)> = Result;
+export type XStaticRef<Stack extends string[], Root extends XSchema, Ref extends string, Normal extends string = XNormal<Ref>, Target extends unknown = XPointerGet<Root, Normal>, Schema extends XSchema = Target extends XSchema ? Target : {}, Result extends unknown = (XCyclicGuard<Stack, Ref> extends true ? XStaticSchema<[...Stack, Ref], Root, Schema> : any)> = Result;
+export {};

package/assets/types/typebox/build/schema/static/required.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XProperties } from '../types/properties.mjs';
+export type XStaticRequired<_Stack extends string[], _Root extends XSchema, Schema extends XSchema, Keys extends string[], Result extends Record<PropertyKey, unknown> = Schema extends XProperties ? {} : Record<Keys[number], unknown>> = Result;