@openclaw/voice-call 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/schema/errors.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Settings } from '../system/settings/index.mjs';
+import { Get as LocaleGet } from '../system/locale/_config.mjs';
+import { Guard } from '../guard/index.mjs';
+import * as Engine from './engine/index.mjs';
+/** Checks a value and returns validation errors */
+export function Errors(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    const settings = Settings.Get();
+    const locale = LocaleGet();
+    const errors = [];
+    const stack = new Engine.Stack(context, schema);
+    const errorContext = new Engine.ErrorContext(error => {
+        if (Guard.IsGreaterEqualThan(errors.length, settings.maxErrors))
+            return;
+        return errors.push({ ...error, message: locale(error) });
+    });
+    const result = Engine.ErrorSchema(stack, errorContext, '#', '', schema, value);
+    return [result, errors];
+}

package/node_modules/typebox/build/schema/index.d.mts

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

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

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

package/node_modules/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/node_modules/typebox/build/schema/parse.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Check } from './check.mjs';
+import { Errors } from './errors.mjs';
+// ------------------------------------------------------------------
+// ParseError
+// ------------------------------------------------------------------
+export class ParseError {
+    constructor(schema, value, errors) {
+        this.schema = schema;
+        this.value = value;
+        this.errors = errors;
+    }
+}
+/** Parses a value against the provided schema */
+export function Parse(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    if (!Check(context, schema, value)) {
+        const [_result, errors] = Errors(context, schema, value);
+        throw new ParseError(schema, value, errors);
+    }
+    return value;
+}

package/node_modules/typebox/build/schema/pointer/index.d.mts

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

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

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

package/node_modules/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/node_modules/typebox/build/schema/pointer/pointer.mjs

@@ -0,0 +1,106 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Asserts
+// ------------------------------------------------------------------
+function AssertNotRoot(indices) {
+    if (indices.length === 0)
+        throw Error('Cannot set root');
+}
+function AssertCanSet(value) {
+    if (!Guard.IsObject(value))
+        throw Error('Cannot set value');
+}
+function AssertIndex(index) {
+    if (Guard.IsUnsafePropertyKey(index))
+        throw Error('Pointer contains unsafe property key');
+}
+function AssertIndices(indices) {
+    for (const index of indices)
+        AssertIndex(index);
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+function IsNumericIndex(index) {
+    return /^(0|[1-9]\d*)$/.test(index);
+}
+function TakeIndexRight(indices) {
+    return [
+        indices.slice(0, indices.length - 1),
+        indices.slice(indices.length - 1)[0]
+    ];
+}
+function HasIndex(index, value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
+}
+function GetIndex(index, value) {
+    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
+}
+function GetIndices(indices, value) {
+    return indices.reduce((value, index) => GetIndex(index, value), value);
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+/** Returns an array of path indices for the given pointer */
+export function Indices(pointer) {
+    if (Guard.IsEqual(pointer.length, 0))
+        return [];
+    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if a value exists at the current pointer */
+export function Has(value, pointer) {
+    let current = value;
+    return Indices(pointer).every(index => {
+        if (!HasIndex(index, current))
+            return false;
+        current = current[index];
+        return true;
+    });
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a value at the pointer, or undefined if not exists */
+export function Get(value, pointer) {
+    const indices = Indices(pointer);
+    return GetIndices(indices, value);
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export function Set(value, pointer, next) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    AssertIndices(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    parent[index] = next;
+    return value;
+}
+// ------------------------------------------------------------------
+// Delete
+// ------------------------------------------------------------------
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export function Delete(value, pointer) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    AssertIndices(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
+        parent.splice(+index, 1);
+    }
+    else {
+        delete parent[index];
+    }
+    return value;
+}

package/node_modules/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/node_modules/typebox/build/schema/pointer/pointer_get.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/resolve/index.d.mts

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

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

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

package/node_modules/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/node_modules/typebox/build/schema/resolve/ref.mjs

@@ -0,0 +1,146 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// Match: Id
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    if (schema.$id === ref.hash)
+        return schema;
+    const absoluteId = new URL(schema.$id, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Anchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: DynamicAnchor
+// ------------------------------------------------------------------
+function MatchDynamicAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: Hash
+//
+// Resolves JSON Pointer fragments only. Plain anchor-style fragments
+// (no leading '/') are handled exclusively by MatchAnchor and
+// MatchDynamicAnchor to prevent accidentally resolving an anchor name
+// as a pointer into the schema tree.
+//
+// ------------------------------------------------------------------
+function MatchHash(schema, _base, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    if (!ref.hash.startsWith('#'))
+        return undefined;
+    const fragment = decodeURIComponent(ref.hash.slice(1));
+    if (!fragment.startsWith('/'))
+        return undefined;
+    return Pointer.Get(schema, fragment);
+}
+// ------------------------------------------------------------------
+// Match
+// ------------------------------------------------------------------
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsDynamicAnchor(schema)) {
+        const result = MatchDynamicAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function FromObject(schema, base, ref) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        const match = FromValue(schema[key], base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(schema, base, ref) {
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema)
+        ? new URL(schema.$id, base.href)
+        : base;
+    if (Schema.IsSchemaObject(schema)) {
+        const result = Match(schema, nextBase, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Guard.IsArray(schema))
+        return FromArray(schema, nextBase, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, nextBase, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export function Ref(schema, ref) {
+    const defaultBase = new URL('http://unknown/');
+    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, defaultBase.href) : defaultBase;
+    const initialRef = new URL(ref, initialBase.href);
+    return FromValue(schema, initialBase, initialRef);
+}
+// ------------------------------------------------------------------
+// DynamicRef
+// ------------------------------------------------------------------
+export function DynamicRef(root, base, dynamicRef, dynamicAnchors) {
+    // Resolve the static target using either the local base (for fragment‑only references)
+    // or the document root (for absolute URI references).
+    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
+        ? Ref(base, dynamicRef.$dynamicRef)
+        : Ref(root, dynamicRef.$dynamicRef);
+    if (Guard.IsUndefined(fragmentTarget))
+        return undefined;
+    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
+    // If it does not, return the static target unchanged.
+    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
+        return fragmentTarget;
+    // Extract the fragment portion of the reference. According to the test suite,
+    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
+    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
+    const fragment = new URL(dynamicRef.$dynamicRef, 'http://unknown/').hash;
+    if (fragment.startsWith('#/'))
+        return fragmentTarget;
+    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
+    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
+    // find() returns the outermost (first encountered) match, which is the correct
+    // lexical scope per the specification.
+    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
+    return anchorTarget ?? fragmentTarget;
+}

package/node_modules/typebox/build/schema/resolve/resolve.d.mts

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

package/node_modules/typebox/build/schema/resolve/resolve.mjs

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

package/node_modules/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/node_modules/typebox/build/schema/schema.mjs

@@ -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/node_modules/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/node_modules/typebox/build/schema/static/_canonical.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/_comparer.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/_elements.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/additionalProperties.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/allOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/anyOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/const.d.mts

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

package/node_modules/typebox/build/schema/static/const.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/enum.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/if.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/index.d.mts

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

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

@@ -0,0 +1 @@
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/items.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/oneOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/patternProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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/node_modules/typebox/build/schema/static/prefixItems.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/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 {};