@openclaw/lobster 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/type/script/token/unsigned_integer.mjs

@@ -0,0 +1,26 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Many } from './internal/many.mjs';
+import { Digit } from './internal/char.mjs';
+import { Zero } from './internal/char.mjs';
+import { NonZero } from './internal/char.mjs';
+import { UnderScore } from './internal/char.mjs';
+function TakeNonZero(input) {
+    return Take(NonZero, input);
+}
+const AllowedDigits = [...Digit, UnderScore];
+function TakeDigits(input) {
+    return Many(AllowedDigits, [UnderScore], input);
+}
+function TakeUnsignedInteger(input) {
+    return Match(Take([Zero], input), (Zero, ZeroRest) => [Zero, ZeroRest], () => Match(TakeNonZero(input), (NonZero, NonZeroRest) => Match(TakeDigits(NonZeroRest), (Digits, DigitsRest) => [`${NonZero}${Digits}`, DigitsRest], () => []), // fail: did not match Digits
+    () => [])); // fail: did not match NonZero
+}
+/** Matches if next is a UnsignedInteger */
+export function UnsignedInteger(input) {
+    return TakeUnsignedInteger(Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/unsigned_number.d.mts

@@ -0,0 +1,17 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TDigit, type TUnderScore } from './internal/char.mjs';
+import { type TDot } from './internal/char.mjs';
+import { type TUnsignedInteger } from './unsigned_integer.mjs';
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TIsLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [string, string] ? true : false);
+type TTakeFractional<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input> extends [infer Digits extends string, infer DigitsRest extends string] ? Digits extends '' ? [] : [Digits, DigitsRest] : []);
+type TLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`0${Dot}${Fractional}`, FractionalRest] : [] : []);
+type TLeadingInteger<Input extends string> = (TUnsignedInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string] ? TTake<[TDot], IntegerRest> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`${Integer}${Dot}${Fractional}`, FractionalRest] : [`${Integer}`, DotRest] : [`${Integer}`, IntegerRest] : []);
+type TTakeUnsignedNumber<Input extends string> = (TIsLeadingDot<Input> extends true ? TLeadingDot<Input> : TLeadingInteger<Input>);
+/** Matches if next is a UnsignedNumber */
+export type TUnsignedNumber<Input extends string> = (TTakeUnsignedNumber<TTrim<Input>>);
+/** Matches if next is a UnsignedNumber */
+export declare function UnsignedNumber<Input extends string>(input: Input): TUnsignedNumber<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/unsigned_number.mjs

@@ -0,0 +1,38 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { IsMatch, Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Many } from './internal/many.mjs';
+import { Digit, UnderScore } from './internal/char.mjs';
+import { Dot } from './internal/char.mjs';
+import { UnsignedInteger } from './unsigned_integer.mjs';
+const AllowedDigits = [...Digit, UnderScore];
+function IsLeadingDot(input) {
+    return IsMatch(Take([Dot], input));
+}
+function TakeFractional(input) {
+    return Match(Many(AllowedDigits, [UnderScore], input), (Digits, DigitsRest) => IsEqual(Digits, '')
+        ? [] // fail: no Digits
+        : [Digits, DigitsRest], () => []); // fail: did not match Digits
+}
+function LeadingDot(input) {
+    return Match(Take([Dot], input), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`0${Dot}${Fractional}`, FractionalRest], () => []), // fail: did not match Fractional
+    () => []); // fail: did not match Dot
+}
+function LeadingInteger(input) {
+    return Match(UnsignedInteger(input), (Integer, IntegerRest) => Match(Take([Dot], IntegerRest), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`${Integer}${Dot}${Fractional}`, FractionalRest], () => [`${Integer}`, DotRest]), // fail: did not match Fractional, use Integer
+    () => [`${Integer}`, IntegerRest]), // fail: did not match Dot, use Integer
+    () => []); // fail: did not match Integer
+}
+function TakeUnsignedNumber(input) {
+    return (IsLeadingDot(input)
+        ? LeadingDot(input)
+        : LeadingInteger(input));
+}
+/** Matches if next is a UnsignedNumber */
+export function UnsignedNumber(input) {
+    return TakeUnsignedNumber(Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/until.d.mts

@@ -0,0 +1,7 @@
+type TTakeOne<Input extends string> = (Input extends `${infer Left extends string}${infer Right extends string}` ? [Left, Right] : []);
+type TIsInputMatchSentinal<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsInputMatchSentinal<Right, Input> : false);
+/** Match Input until but not including End. No match if End not found. */
+export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (TTakeOne<Input> extends [infer One extends string, infer Rest extends string] ? TIsInputMatchSentinal<End, Input> extends true ? [Result, Input] : TUntil<End, Rest, `${Result}${One}`> : []);
+/** Match Input until but not including End. No match if End not found. */
+export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/until.mjs

@@ -0,0 +1,21 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { IsEqual, TakeLeft } from './internal/guard.mjs';
+function TakeOne(input) {
+    const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
+    return result;
+}
+function IsInputMatchSentinal(end, input) {
+    return TakeLeft(end, (left, right) => input.startsWith(left)
+        ? true
+        : IsInputMatchSentinal(right, input), () => false);
+}
+/** Match Input until but not including End. No match if End not found. */
+export function Until(end, input, result = '') {
+    return Match(TakeOne(input), (One, Rest) => IsInputMatchSentinal(end, input)
+        ? [result, input] // ok: at sentinal 
+        : Until(end, Rest, `${result}${One}`) // fail: advance + 1
+    , () => []);
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/until_1.d.mts

@@ -0,0 +1,5 @@
+import { type TUntil } from './until.mjs';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export type TUntil_1<End extends string[], Input extends string> = (TUntil<End, Input> extends [infer Until extends string, infer UntilRest extends string] ? Until extends '' ? [] : [Until, UntilRest] : []);
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export declare function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input>;

package/node_modules/typebox/build/type/script/token/until_1.mjs

@@ -0,0 +1,12 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { Match } from './internal/match.mjs';
+import { Until } from './until.mjs';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export function Until_1(end, input) {
+    return Match(Until(end, input), (Until, UntilRest) => IsEqual(Until, '')
+        ? [] // fail: match has no characters
+        : [Until, UntilRest], () => []); // fail: did not match Until
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,30 @@
+import { type StaticDirection, type StaticType } from './static.mjs';
+import { type TSchema } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = (Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Omit<Type, '~codec'>>);
+export type TDecodeCallback<Type extends TSchema, Decoded = unknown> = (input: StaticType<[], 'Decode', {}, {}, Type>) => Decoded;
+export type TEncodeCallback<Type extends TSchema, Decoded = unknown> = (input: Decoded) => StaticType<[], 'Decode', {}, {}, Type>;
+export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
+    '~codec': {
+        encode: TDecodeCallback<Type, Decoded>;
+        decode: TEncodeCallback<Type, Decoded>;
+    };
+};
+export declare class EncodeBuilder<Type extends TSchema, Decoded extends unknown> {
+    private readonly type;
+    private readonly decode;
+    constructor(type: Type, decode: globalThis.Function);
+    Encode<Callback extends TEncodeCallback<Type, Decoded>>(callback: Callback): TCodec<Type, Decoded>;
+}
+export declare class DecodeBuilder<Type extends TSchema> {
+    private readonly type;
+    constructor(type: Type);
+    Decode<Callback extends TDecodeCallback<Type>>(callback: Callback): EncodeBuilder<Type, ReturnType<Callback>>;
+}
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type>;
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<Type>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export declare function Encode<Type extends TSchema, Callback extends TEncodeCallback<Type, unknown>>(type: Type, callback: Callback): TCodec<Type, unknown>;
+export declare function IsCodec(value: unknown): value is TCodec;

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

@@ -0,0 +1,61 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../system/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+export class EncodeBuilder {
+    constructor(type, decode) {
+        this.type = type;
+        this.decode = decode;
+    }
+    Encode(callback) {
+        const type = this.type;
+        const decode = IsCodec(type) ? (value) => this.decode(type['~codec'].decode(value)) : this.decode;
+        const encode = IsCodec(type) ? (value) => type['~codec'].encode(callback(value)) : callback;
+        const codec = { decode, encode };
+        return Memory.Update(this.type, { '~codec': codec }, {});
+    }
+}
+export class DecodeBuilder {
+    constructor(type) {
+        this.type = type;
+    }
+    Decode(callback) {
+        return new EncodeBuilder(this.type, callback);
+    }
+}
+// ------------------------------------------------------------------
+// Bidirectional
+// ------------------------------------------------------------------
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export function Codec(type) {
+    return new DecodeBuilder(type);
+}
+// ------------------------------------------------------------------
+// Unidirectional
+// ------------------------------------------------------------------
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export function Decode(type, callback) {
+    return Codec(type).Decode(callback).Encode(() => {
+        throw Error('Encode not implemented');
+    });
+}
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export function Encode(type, callback) {
+    return Codec(type).Decode(() => {
+        throw Error('Decode not implemented');
+    }).Encode(callback);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsCodec(value) {
+    return IsSchema(value) &&
+        Guard.HasPropertyKey(value, '~codec') &&
+        Guard.IsObject(value['~codec']) &&
+        Guard.HasPropertyKey(value['~codec'], 'encode') &&
+        Guard.HasPropertyKey(value['~codec'], 'decode');
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes Immutable from the given type. */
+export type TImmutableRemove<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Immutable from the given type. */
+export declare function ImmutableRemove<Type extends TSchema>(type: Type): TImmutableRemove<Type>;
+/** Adds Immutable to the given type. */
+export type TImmutableAdd<Type extends TSchema = TSchema> = ('~immutable' extends keyof Type ? Type : TImmutable<Type>);
+/** Adds Immutable to the given type. */
+export declare function ImmutableAdd<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+export type TImmutable<Type extends TSchema = TSchema> = (Type & {
+    '~immutable': true;
+});
+/** Applies an Immutable modifier to the given type. */
+export declare function Immutable<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+/** Returns true if the given value is a TImmutable */
+export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

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

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes Immutable from the given type. */
+export function ImmutableRemove(type) {
+    return Memory.Discard(type, ['~immutable']);
+}
+/** Adds Immutable to the given type. */
+export function ImmutableAdd(type) {
+    return Memory.Update(type, { '~immutable': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Immutable modifier to the given type. */
+export function Immutable(type) {
+    return ImmutableAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TImmutable */
+export function IsImmutable(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~immutable');
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes Optional from the given type. */
+export type TOptionalRemove<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Optional from the given type. */
+export declare function OptionalRemove<Type extends TSchema>(type: Type): TOptionalRemove<Type>;
+/** Adds Optional to the given type. */
+export type TOptionalAdd<Type extends TSchema = TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
+/** Adds Optional to the given type. */
+export declare function OptionalAdd<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+export type TOptional<Type extends TSchema = TSchema> = (Type & {
+    '~optional': true;
+});
+/** Applies an Optional modifier to the given type. */
+export declare function Optional<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+/** Returns true if the given value is TOptional */
+export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

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

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes Optional from the given type. */
+export function OptionalRemove(type) {
+    const result = Memory.Discard(type, ['~optional']);
+    return result;
+}
+/** Adds Optional to the given type. */
+export function OptionalAdd(type) {
+    return Memory.Update(type, { '~optional': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Optional modifier to the given type. */
+export function Optional(type) {
+    return OptionalAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TOptional */
+export function IsOptional(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~optional');
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes a Readonly property modifier from the given type. */
+export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes a Readonly property modifier from the given type. */
+export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
+/** Adds a Readonly property modifier to the given type. */
+export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
+/** Adds a Readonly property modifier to the given type. */
+export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+export type TReadonly<Type extends TSchema = TSchema> = (Type & {
+    '~readonly': true;
+});
+/** Applies an Readonly property modifier to the given type. */
+export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+/** Returns true if the given value is a TReadonly */
+export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

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

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes a Readonly property modifier from the given type. */
+export function ReadonlyRemove(type) {
+    return Memory.Discard(type, ['~readonly']);
+}
+/** Adds a Readonly property modifier to the given type. */
+export function ReadonlyAdd(type) {
+    return Memory.Update(type, { '~readonly': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Readonly property modifier to the given type. */
+export function Readonly(type) {
+    return ReadonlyAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TReadonly */
+export function IsReadonly(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~readonly');
+}

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

@@ -0,0 +1,26 @@
+import { type TSchema } from './schema.mjs';
+import { type Static } from './static.mjs';
+/** Applies a Refine check to the given type. */
+export type TRefineAdd<Type extends TSchema = TSchema> = ('~refine' extends keyof Type ? Type : TRefine<Type>);
+/** Applies a Refine check to the given type. */
+export declare function RefineAdd<Type extends TSchema>(type: Type, refinement: TRefinement<Type>): TRefineAdd<Type>;
+/** Represents a type with embedded Refine check. */
+export type TRefine<Type extends TSchema = TSchema> = (Type & {
+    '~refine': TRefinement<Type>[];
+});
+export type TRefineCheckCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => boolean;
+export type TRefineErrorCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => string;
+export interface TRefinement<Type extends TSchema = TSchema> {
+    check: TRefineCheckCallback<Type>;
+    error: TRefineErrorCallback<Type>;
+}
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, error: TRefineErrorCallback<Type>): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>): TRefineAdd<Type>;
+/** @deprecated Use the error callback signature to generate error message. This overload will be removed in the next version  */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, message: string): TRefineAdd<Type>;
+/** Returns true if the given value is a TRefinement. */
+export declare function IsRefinement(value: unknown): value is TRefinement;
+/** Returns true if the given value is a TRefine. */
+export declare function IsRefine(value: unknown): value is TRefine;

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

@@ -0,0 +1,37 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Applies a Refine check to the given type. */
+export function RefineAdd(type, refinement) {
+    const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
+    return Memory.Update(type, { '~refine': refinements }, {});
+}
+/** Refines a type with an explicit check */
+export function Refine(...args) {
+    const [type, check, error_or_message] = Arguments.Match(args, {
+        3: (type, check, error) => [type, check, error],
+        2: (type, check) => [type, check, () => 'Refine Error'],
+    });
+    const error = Guard.IsString(error_or_message) ? () => error_or_message : error_or_message;
+    return RefineAdd(type, { check, error });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TRefinement. */
+export function IsRefinement(value) {
+    return Guard.IsObjectNotArray(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'error')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.error);
+}
+/** Returns true if the given value is a TRefine. */
+export function IsRefine(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, '~refine')
+        && Guard.IsArray(value['~refine'])
+        && Guard.Every(value['~refine'], 0, value => IsRefinement(value));
+}

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticAny = any;
+/** Represents a Any type. */
+export interface TAny extends TSchema {
+    '~kind': 'Any';
+}
+/** Creates a Any type. */
+export declare function Any(options?: TSchemaOptions): TAny;
+/** Returns true if the given value is a TAny. */
+export declare function IsAny(value: unknown): value is TAny;

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

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

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

@@ -0,0 +1,18 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TArrayOptions } from './schema.mjs';
+import { type TImmutable } from './_immutable.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Array extends TSchema, Item extends TSchema, Result extends readonly unknown[] = Array extends TImmutable ? readonly StaticType<Stack, Direction, Context, This, Item>[] : StaticType<Stack, Direction, Context, This, Item>[]> = Result;
+/** Represents an Array type. */
+export interface TArray<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Array';
+    type: 'array';
+    items: Type;
+}
+/** Creates an Array type. */
+export declare function _Array_<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
+export { _Array_ as Array };
+/** Returns true if the given value is a TArray. */
+export declare function IsArray(value: unknown): value is TArray;
+/** Extracts options from a TArray. */
+export declare function ArrayOptions(type: TArray): TArrayOptions;

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

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Array type. */
+export function _Array_(items, options) {
+    return Memory.Create({ '~kind': 'Array' }, { type: 'array', items }, options);
+}
+export { _Array_ as Array }; // Prevent Collision With Global Scope
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TArray. */
+export function IsArray(value) {
+    return IsKind(value, 'Array');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TArray. */
+export function ArrayOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'items']);
+}

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

@@ -0,0 +1,20 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticAsyncIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = AsyncIterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
+/** Represents a AsyncIterator. */
+export interface TAsyncIterator<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'AsyncIterator';
+    type: 'asyncIterator';
+    iteratorItems: Type;
+}
+/**
+ * Creates a AsyncIterator type.
+ *
+ * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
+ */
+export declare function AsyncIterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TAsyncIterator<Type>;
+/** Returns true if the given value is a TAsyncIterator */
+export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator;
+/** Extracts options from a TAsyncIterator. */
+export declare function AsyncIteratorOptions(type: TAsyncIterator): TSchemaOptions;

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

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/**
+ * Creates a AsyncIterator type.
+ *
+ * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
+ */
+export function AsyncIterator(iteratorItems, options) {
+    return Memory.Create({ '~kind': 'AsyncIterator' }, { type: 'asyncIterator', iteratorItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TAsyncIterator */
+export function IsAsyncIterator(value) {
+    return IsKind(value, 'AsyncIterator');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TAsyncIterator. */
+export function AsyncIteratorOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
+}

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

@@ -0,0 +1,50 @@
+import { type TSchema } from './schema.mjs';
+import { type XGuard, type XGuardInterface } from '../../schema/types/index.mjs';
+export type StaticBase<Value extends unknown> = Value;
+/**
+ * @deprecated Use Type.Refine() + Type.Unsafe() instead.
+ *
+ *
+ * **Reason:** It is noted that JavaScript class instances do not behave like
+ * plain objects during structural clone or when the TB compositor needs to
+ * assign dynamic modifier properties (such as '~optional').
+ *
+ * Because the TypeBox compositor needs to transform schematics via object clone /
+ * property spread, these operations can result in class instance types losing
+ * methods on the prototype (via clone), which can lead to unexpected structures being
+ * returned. This has led to special-case (non-clone) handling for Base which needs
+ * to be removed as it has proven orthogonal to the TypeBox 1.x design.
+ *
+ * The Base type was introduced in 1.x to try integrate / embed Standard Schema into JSON
+ * Schema; however, support for integrated Standard Schema embedding will not be continued
+ * in TypeBox. This type will be removed in the next minor revision of TypeBox.
+ *
+ * ```typescript
+ * // (Deprecated)
+ * class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }
+ *
+ * // (Future)
+ * const DateType = Type.Refine(Type.Unsafe<Date>({}), value => value instanceof Date)
+ * ```
+ */
+export declare class Base<Value extends unknown = unknown> implements TSchema, XGuard<Value> {
+    readonly '~kind': 'Base';
+    readonly '~guard': XGuardInterface<Value>;
+    constructor();
+    /** Checks a value or returns false if invalid */
+    Check(_value: unknown): _value is Value;
+    /** Returns errors for a value. Return an empty array if valid.  */
+    Errors(_value: unknown): object[];
+    /** Converts a value into this type */
+    Convert(value: unknown): unknown;
+    /** Cleans a value according to this type */
+    Clean(value: unknown): unknown;
+    /** Returns a default value for this type */
+    Default(value: unknown): unknown;
+    /** Creates a new instance of this type */
+    Create(): Value;
+    /** Clones this type  */
+    Clone(): Base;
+}
+/** Returns true if the given value is a Base type. */
+export declare function IsBase(value: unknown): value is Base;