@openclaw/facetime 0.0.0 → 2026.9.7

package/node_modules/typebox/build/type/types/null.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Null type. */
+export function Null(options) {
+    return Memory.Create({ '~kind': 'Null' }, { type: 'null' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TNull. */
+export function IsNull(value) {
+    return IsKind(value, 'Null');
+}

package/node_modules/typebox/build/type/types/number.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
+export type StaticNumber = number;
+/** Represents a Number type. */
+export interface TNumber extends TSchema {
+    '~kind': 'Number';
+    type: 'number';
+}
+/** Creates a Number type. */
+export declare function Number(options?: TNumberOptions): TNumber;
+/** Returns true if the given value is a TNumber. */
+export declare function IsNumber(value: unknown): value is TNumber;

package/node_modules/typebox/build/type/types/number.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+export const NumberPattern = '-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Number type. */
+export function Number(options) {
+    return Memory.Create({ '~kind': 'Number' }, { type: 'number' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TNumber. */
+export function IsNumber(value) {
+    return IsKind(value, 'Number');
+}

package/node_modules/typebox/build/type/types/object.d.mts

@@ -0,0 +1,18 @@
+import { type StaticDirection } from './static.mjs';
+import { type TSchema, type TObjectOptions } from './schema.mjs';
+import { type TProperties, type TRequiredArray, type StaticProperties } from './properties.mjs';
+export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
+/** Represents an Object type. */
+export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
+    '~kind': 'Object';
+    type: 'object';
+    properties: Properties;
+    required: TRequiredArray<Properties>;
+}
+/** Creates an Object type. */
+export declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
+export { _Object_ as Object };
+/** Returns true if the given value is TObject. */
+export declare function IsObject(value: unknown): value is TObject;
+/** Extracts options from a TObject. */
+export declare function ObjectOptions(type: TObject): TObjectOptions;

package/node_modules/typebox/build/type/types/object.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+import { RequiredArray } from './properties.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Object type. */
+export function _Object_(properties, options = {}) {
+    const requiredKeys = RequiredArray(properties);
+    const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
+    return Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
+}
+export { _Object_ as Object }; // Prevent Collision With Global Scope
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TObject. */
+export function IsObject(value) {
+    return IsKind(value, 'Object');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TObject. */
+export function ObjectOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'properties', 'required']);
+}

package/node_modules/typebox/build/type/types/parameter.d.mts

@@ -0,0 +1,17 @@
+import { type TSchema } from './schema.mjs';
+import { type TUnknown } from './unknown.mjs';
+/** Represents a Generic parameter. */
+export interface TParameter<Name extends string = string, Extends extends TSchema = TSchema, Equals extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Parameter';
+    name: Name;
+    extends: Extends;
+    equals: Equals;
+}
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends, equals: Equals): TParameter<Name, Extends, Equals>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends): TParameter<Name, Extends, Extends>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string>(name: Name): TParameter<Name, TUnknown, TUnknown>;
+/** Returns true if the given value is TParameter. */
+export declare function IsParameter(value: unknown): value is TParameter;

package/node_modules/typebox/build/type/types/parameter.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+import { Unknown } from './unknown.mjs';
+/** Creates a Parameter type. */
+export function Parameter(...args) {
+    const [name, extends_, equals] = Arguments.Match(args, {
+        3: (name, extends_, equals) => [name, extends_, equals],
+        2: (name, extends_) => [name, extends_, extends_],
+        1: (name) => [name, Unknown(), Unknown()],
+    });
+    return Memory.Create({ '~kind': 'Parameter' }, { name, extends: extends_, equals }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TParameter. */
+export function IsParameter(value) {
+    return IsKind(value, 'Parameter');
+}

package/node_modules/typebox/build/type/types/properties.d.mts

@@ -0,0 +1,43 @@
+import { type StaticType, type StaticDirection, type StaticEvaluate } from './static.mjs';
+import { type TSchema } from './schema.mjs';
+import { type TOptional } from './_optional.mjs';
+import { type TReadonly } from './_readonly.mjs';
+import { type TUnionToTuple } from '../engine/helpers/union.mjs';
+type ReadonlyOptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
+}[keyof Properties]> = Result;
+type ReadonlyKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? never : Key) : never;
+}[keyof Properties]> = Result;
+type OptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TOptional<TSchema> ? (Properties[Key] extends TReadonly<Properties[Key]> ? never : Key) : never;
+}[keyof Properties]> = Result;
+type RequiredKeys<Properties extends TProperties, Result extends PropertyKey = keyof Omit<Properties, ReadonlyOptionalKeys<Properties> | ReadonlyKeys<Properties> | OptionalKeys<Properties>>> = Result;
+type StaticPropertiesWithModifiers<Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown>> = StaticEvaluate<Readonly<Partial<Pick<PropertiesWithoutModifiers, ReadonlyOptionalKeys<Properties>>>> & Readonly<Pick<PropertiesWithoutModifiers, ReadonlyKeys<Properties>>> & Partial<Pick<PropertiesWithoutModifiers, OptionalKeys<Properties>>> & Required<Pick<PropertiesWithoutModifiers, RequiredKeys<Properties>>>>;
+type StaticPropertiesWithoutModifiers<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, Result extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: StaticType<Stack, Direction, Context, This, Properties[Key]>;
+}> = Result;
+export type StaticProperties<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithoutModifiers<Stack, Direction, Context, This, Properties>, PropertiesWithModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithModifiers<Properties, PropertiesWithoutModifiers>, Result extends Record<PropertyKey, unknown> = {
+    [Key in keyof PropertiesWithModifiers]: PropertiesWithModifiers[Key];
+}> = Result;
+/** Represents a Record<PropertyKey, TSchema> structure. */
+export interface TProperties extends TSchema {
+    [key: PropertyKey]: TSchema;
+}
+/** Creates a RequiredArray derived from the given TProperties value. */
+export type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
+    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
+}, RequiredKeys extends string[] = TUnionToTuple<Extract<keyof RequiredProperties, string>>, Result extends string[] | undefined = RequiredKeys extends [] ? undefined : RequiredKeys> = Result;
+/** Creates a RequiredArray derived from the given TProperties value. */
+export declare function RequiredArray<Properties extends TProperties>(properties: Properties): TRequiredArray<Properties>;
+type TKeyToString<Key extends number | string> = `${Key}`;
+/** Extracts a tuple of keys from a TProperties value. */
+export type TPropertyKeys<Properties extends TProperties, ExtractKey extends number | string = Extract<keyof Properties, number | string>, StringKey extends string = TKeyToString<ExtractKey>, Result extends string[] = TUnionToTuple<StringKey>> = Result;
+/** Extracts a tuple of keys from a TProperties value. */
+export declare function PropertyKeys<Properties extends TProperties>(properties: Properties): TPropertyKeys<Properties>;
+type TPropertyValuesReduce<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Properties ? TPropertyValuesReduce<Properties, Right, [...Result, Properties[Left]]> : TPropertyValuesReduce<Properties, Right, Result> : Result;
+/** Extracts a tuple of property values from a TProperties value. */
+export type TPropertyValues<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, Result extends TSchema[] = TPropertyValuesReduce<Properties, Keys>> = Result;
+/** Extracts a tuple of property values from a TProperties value. */
+export declare function PropertyValues<Properties extends TProperties>(properties: Properties): TPropertyValues<Properties>;
+export {};

package/node_modules/typebox/build/type/types/properties.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsOptional } from './_optional.mjs';
+/** Creates a RequiredArray derived from the given TProperties value. */
+export function RequiredArray(properties) {
+    return Guard.Keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+/** Extracts a tuple of keys from a TProperties value. */
+export function PropertyKeys(properties) {
+    return Guard.Keys(properties);
+}
+/** Extracts a tuple of property values from a TProperties value. */
+export function PropertyValues(properties) {
+    return Guard.Values(properties);
+}

package/node_modules/typebox/build/type/types/record.d.mts

@@ -0,0 +1,52 @@
+import { type TSchema, type TObjectOptions } from './schema.mjs';
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TProperties } from './properties.mjs';
+import { type TInteger } from './integer.mjs';
+import { type TNumber } from './number.mjs';
+import { type TString } from './string.mjs';
+import { type TDeferred } from './deferred.mjs';
+import { type TTemplateLiteralStatic } from '../engine/template_literal/index.mjs';
+import { type TTemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
+import { type TRecordAction } from '../engine/record/instantiate.mjs';
+type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
+export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = Record<StaticKey, StaticValue>> = Result;
+export type TStringKey = typeof StringKey;
+export type TIntegerKey = typeof IntegerKey;
+export type TNumberKey = typeof NumberKey;
+export declare const IntegerKey = "^-?(?:0|[1-9][0-9]*)$";
+export declare const NumberKey = "^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?$";
+export declare const StringKey = "^.*$";
+export interface TRecord<Key extends string = string, Value extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Record';
+    type: 'object';
+    patternProperties: {
+        [_ in Key]: Value;
+    };
+}
+/** Represents a deferred Record action. */
+export type TRecordDeferred<Key extends TSchema = TSchema, Value extends TSchema = TSchema> = (TDeferred<'Record', [Key, Value]>);
+/** Represents a deferred Record action. */
+export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
+/** Creates a Record type. */
+export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
+/** Creates a Record type from regular expression pattern. */
+export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TRecord<Pattern, Value>;
+/** Transforms a Record Pattern to a Type */
+export type TRecordPatternToType<Pattern extends string, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
+/** Transforms a Record Pattern to a Type */
+export declare function RecordPatternToType<Pattern extends string>(pattern: Pattern): TRecordPatternToType<Pattern>;
+/** Extracts the Pattern from a Record type */
+export type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
+/** Extracts the Pattern from a Record type */
+export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
+/** Extracts the Key from a Record type */
+export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = TRecordPatternToType<Pattern>> = Result;
+/** Extracts the Key from a Record type */
+export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+/** Extracts the Value from a Record type */
+export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
+/** Extracts the Value from a Record type */
+export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
+export declare function IsRecord(value: unknown): value is TRecord;
+export declare function RecordOptions(type: TRecord): TObjectOptions;
+export {};

package/node_modules/typebox/build/type/types/record.mjs

@@ -0,0 +1,66 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsKind } from './schema.mjs';
+import { Integer, IntegerPattern } from './integer.mjs';
+import { Number, NumberPattern } from './number.mjs';
+import { String, StringPattern } from './string.mjs';
+import { Deferred } from './deferred.mjs';
+import { TemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
+import { CreateRecord } from '../engine/record/record_create.mjs';
+import { RecordAction } from '../engine/record/instantiate.mjs';
+export const IntegerKey = `^${IntegerPattern}$`;
+export const NumberKey = `^${NumberPattern}$`;
+export const StringKey = `^${StringPattern}$`;
+/** Represents a deferred Record action. */
+export function RecordDeferred(key, value, options = {}) {
+    return Deferred('Record', [key, value], options);
+}
+// -------------------------------------------------------------------
+// Factory
+// -------------------------------------------------------------------
+/** Creates a Record type. */
+export function Record(key, value, options = {}) {
+    return RecordAction(key, value, options);
+}
+// -------------------------------------------------------------------
+// RecordFromPattern
+// -------------------------------------------------------------------
+/** Creates a Record type from regular expression pattern. */
+export function RecordFromPattern(pattern, value) {
+    return CreateRecord(pattern, value);
+}
+/** Transforms a Record Pattern to a Type */
+export function RecordPatternToType(pattern) {
+    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
+        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
+            Guard.IsEqual(pattern, NumberKey) ? Number() :
+                TemplateLiteralDecodeUnsafe(pattern));
+    return result;
+}
+/** Extracts the Pattern from a Record type */
+export function RecordPattern(type) {
+    return Guard.Keys(type.patternProperties)[0];
+}
+/** Extracts the Key from a Record type */
+export function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    const result = RecordPatternToType(pattern);
+    return result;
+}
+/** Extracts the Value from a Record type */
+export function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
+}
+// -------------------------------------------------------------------
+// Guard
+// -------------------------------------------------------------------
+export function IsRecord(value) {
+    return IsKind(value, 'Record');
+}
+// -------------------------------------------------------------------
+// Options
+// -------------------------------------------------------------------
+export function RecordOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'patternProperties']);
+}

package/node_modules/typebox/build/type/types/ref.d.mts

@@ -0,0 +1,19 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+import { type TObject } from './object.mjs';
+import { type TUnknown } from './unknown.mjs';
+type CyclicStackLength<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : CyclicStackLength<Right, MaxLength, [...Buffer, Left]> : true);
+type CyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? CyclicStackLength<Stack, 2> : true);
+type StaticGuardedRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Type extends TSchema> = (CyclicGuard<Stack, Ref> extends true ? StaticType<[...Stack, Ref], Direction, Context, This, Type> : any);
+export type StaticRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Target extends TSchema = Ref extends keyof Context ? Context[Ref] : TUnknown, Result extends unknown = Target extends TObject ? StaticType<[], Direction, Context, This, Target> : StaticGuardedRef<Stack, Direction, Context, This, Ref, Target>> = Result;
+/** Represents a type reference. */
+export interface TRef<Ref extends string = string> extends TSchema {
+    '~kind': 'Ref';
+    $ref: Ref;
+}
+/** Creates a Ref type. */
+export declare function Ref<Ref extends string>(ref: Ref, options?: TSchemaOptions): TRef<Ref>;
+/** Returns true if the given value is TRef. */
+export declare function IsRef(value: unknown): value is TRef;
+export {};

package/node_modules/typebox/build/type/types/ref.mjs

@@ -0,0 +1,18 @@
+// deno-lint-ignore-file no-explicit-any
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Ref type. */
+export function Ref(ref, options) {
+    return Memory.Create({ ['~kind']: 'Ref' }, { $ref: ref }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TRef. */
+export function IsRef(value) {
+    return IsKind(value, 'Ref');
+}

package/node_modules/typebox/build/type/types/rest.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+/** Represents a Rest instruction. */
+export interface TRest<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Rest';
+    type: 'rest';
+    items: Type;
+}
+/** Creates a Rest instruction type. */
+export declare function Rest<Type extends TSchema>(type: Type): TRest<Type>;
+/** Returns true if the given value is TRest. */
+export declare function IsRest(value: unknown): value is TRest;

package/node_modules/typebox/build/type/types/rest.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** Creates a Rest instruction type. */
+export function Rest(type) {
+    return Memory.Create({ '~kind': 'Rest' }, { type: 'rest', items: type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TRest. */
+export function IsRest(value) {
+    return IsKind(value, 'Rest');
+}

package/node_modules/typebox/build/type/types/schema.d.mts

@@ -0,0 +1,176 @@
+export interface TSchema {
+}
+export declare function IsKind<Kind extends string>(value: unknown, kind: Kind): value is {
+    ['~kind']: Kind;
+};
+export declare function IsSchema(value: unknown): value is TSchema;
+export interface TSchemaOptions {
+    /**
+     * Allows for additional, unlisted properties to be included, typically for extensibility.
+     */
+    [key: PropertyKey]: unknown;
+    /**
+     * Specifies the URI of a JSON Schema that the current schema adheres to.
+     */
+    $schema?: string;
+    /**
+     * A URI that serves as a unique identifier for the schema.
+     */
+    $id?: string;
+    /**
+     * A short explanation about the purpose of the data described by the schema.
+     */
+    title?: string;
+    /**
+     * A detailed explanation of the data described by the schema.
+     */
+    description?: string;
+    /**
+     * A default value for the data, used when no value is provided.
+     */
+    default?: unknown;
+    /**
+     * Provides one or more examples of valid data conforming to the schema.
+     */
+    examples?: unknown;
+    /**
+     * Indicates that the data should only be readable and not modified.
+     */
+    readOnly?: boolean;
+    /**
+     * Indicates that the data should only be writable and not read back.
+     */
+    writeOnly?: boolean;
+    /**
+     * A schema to apply conditionally: if the data validates against this schema, 'then' applies.
+     */
+    if?: TSchema;
+    /**
+     * A schema to apply if the data validates against the 'if' schema.
+     */
+    then?: TSchema;
+    /**
+     * A schema to apply if the data does not validate against the 'if' schema.
+     */
+    else?: TSchema;
+}
+export interface TObjectOptions extends TSchemaOptions {
+    /**
+     * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.
+     */
+    additionalProperties?: TSchema | boolean;
+    /**
+     * The minimum number of properties required in the object.
+     */
+    minProperties?: number;
+    /**
+     * The maximum number of properties allowed in the object.
+     */
+    maxProperties?: number;
+    /**
+     * Defines conditional requirements for properties.
+     */
+    dependencies?: Record<string, boolean | TSchema | string[]>;
+    /**
+     * Specifies properties that *must* be present if a given property is present.
+     */
+    dependentRequired?: Record<string, string[]>;
+    /**
+     * Defines schemas that apply if a specific property is present.
+     */
+    dependentSchemas?: Record<string, TSchema>;
+    /**
+     * Maps regular expressions to schemas properties matching a pattern must validate against the schema.
+     */
+    patternProperties?: Record<string, TSchema>;
+    /**
+     * A schema that all property names within the object must validate against.
+     */
+    propertyNames?: TSchema;
+}
+export interface TArrayOptions extends TSchemaOptions {
+    /**
+     * The minimum number of items allowed in the array.
+     */
+    minItems?: number;
+    /**
+     * The maximum number of items allowed in the array.
+     */
+    maxItems?: number;
+    /**
+     * A schema that at least one item in the array must validate against.
+     */
+    contains?: TSchema;
+    /**
+     * The minimum number of array items that must validate against the `contains` schema.
+     */
+    minContains?: number;
+    /**
+     * The maximum number of array items that may validate against the `contains` schema.
+     */
+    maxContains?: number;
+    /**
+     * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.
+     */
+    prefixItems?: TSchema[];
+    /**
+     * If `true`, all items in the array must be unique.
+     */
+    uniqueItems?: boolean;
+}
+export interface TTupleOptions extends TArrayOptions {
+    /**
+     * A schema to apply to any items in the array that were not validated by `prefixItems` or `items`. If `false`, no additional items are allowed.
+     */
+    unevaluatedItems?: TSchema | boolean;
+}
+export interface TIntersectOptions extends TSchemaOptions {
+    /**
+     * A schema to apply to any properties in the object that were not validated by other keywords like `properties`, `patternProperties`, or `additionalProperties`. If `false`, no additional properties are allowed.
+     */
+    unevaluatedProperties?: TSchema | boolean;
+}
+export interface TNumberOptions extends TSchemaOptions {
+    /**
+     * Specifies an exclusive upper limit for the number (number must be less than this value).
+     */
+    exclusiveMaximum?: number | bigint;
+    /**
+     * Specifies an exclusive lower limit for the number (number must be greater than this value).
+     */
+    exclusiveMinimum?: number | bigint;
+    /**
+     * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
+     */
+    maximum?: number | bigint;
+    /**
+     * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
+     */
+    minimum?: number | bigint;
+    /**
+     * Specifies that the number must be a multiple of this value.
+     */
+    multipleOf?: number | bigint;
+}
+export type TFormat = 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'uri' | 'url' | 'uuid' | ({} & string);
+export interface TStringOptions extends TSchemaOptions {
+    /**
+     * Specifies the expected string format. May also be a custom format string.
+     */
+    format?: TFormat;
+    /**
+     * Specifies the minimum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    minLength?: number;
+    /**
+     * Specifies the maximum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    maxLength?: number;
+    /**
+     * Specifies a regular expression pattern that the string value must match.
+     * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.
+     */
+    pattern?: string | RegExp;
+}

package/node_modules/typebox/build/type/types/schema.mjs

@@ -0,0 +1,15 @@
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Kind
+// ------------------------------------------------------------------
+export function IsKind(value, kind) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~kind') && Guard.IsEqual(value["~kind"], kind);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsSchema(value) {
+    return Guard.IsObject(value);
+}

package/node_modules/typebox/build/type/types/static.d.mts

@@ -0,0 +1,45 @@
+import type { StaticCodec, TCodec } from './_codec.mjs';
+import type { StaticAny, TAny } from './any.mjs';
+import type { StaticArray, TArray } from './array.mjs';
+import type { StaticBigInt, TBigInt } from './bigint.mjs';
+import type { StaticBoolean, TBoolean } from './boolean.mjs';
+import type { StaticConstructor, TConstructor } from './constructor.mjs';
+import type { StaticCyclic, TCyclic } from './cyclic.mjs';
+import type { StaticEnum, TEnum, TEnumValue } from './enum.mjs';
+import type { StaticFunction, TFunction } from './function.mjs';
+import type { StaticInteger, TInteger } from './integer.mjs';
+import type { StaticDependent, TDependent } from './dependent.mjs';
+import type { StaticIntersect, TIntersect } from './intersect.mjs';
+import type { StaticLiteral, TLiteral, TLiteralValue } from './literal.mjs';
+import type { StaticNever, TNever } from './never.mjs';
+import type { StaticNull, TNull } from './null.mjs';
+import type { StaticNumber, TNumber } from './number.mjs';
+import type { StaticObject, TObject } from './object.mjs';
+import type { TProperties } from './properties.mjs';
+import type { StaticRecord, TRecord } from './record.mjs';
+import type { StaticRef, TRef } from './ref.mjs';
+import type { TSchema } from './schema.mjs';
+import type { StaticString, TString } from './string.mjs';
+import type { StaticSymbol, TSymbol } from './symbol.mjs';
+import type { StaticTemplateLiteral, TTemplateLiteral } from './template_literal.mjs';
+import type { StaticThis, TThis } from './this.mjs';
+import type { StaticTuple, TTuple } from './tuple.mjs';
+import type { StaticUndefined, TUndefined } from './undefined.mjs';
+import type { StaticUnion, TUnion } from './union.mjs';
+import type { StaticUnknown, TUnknown } from './unknown.mjs';
+import type { StaticUnsafe, TUnsafe } from './unsafe.mjs';
+import type { StaticVoid, TVoid } from './void.mjs';
+import type { XStatic } from '../../schema/static/static.mjs';
+export type StaticEvaluate<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type StaticDirection = 'Encode' | 'Decode';
+export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Items extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type, Items> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? StaticDependent<Stack, Direction, Context, This, If, Then, Else> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Stack, Direction, Context, This, Properties> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Stack, Direction, Context, This> : Type extends TTuple<infer Items extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Type, Items> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
+/** Infers a static type from a TypeBox type using Parse logic. */
+export type StaticParse<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;
+/** Infers a static type from a TypeBox type using Decode logic. */
+export type StaticDecode<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Decode', Context, {}, Type>> = Result;
+/** Infers a static type from a TypeBox type using Encode logic. */
+export type StaticEncode<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;
+/** Infers a static type from a TypeBox type. */
+export type Static<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;