@openclaw/slack 2026.7.1-beta.2 → 2026.7.1-beta.4

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

@@ -1,40 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from '../types/schema.mjs';
-// ------------------------------------------------------------------
-// Action
-// ------------------------------------------------------------------
-/** Creates an OptionalAddAction. */
-export function OptionalAddAction(type) {
-    return Memory.Create({ ['~kind']: 'OptionalAddAction' }, { type }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if this value is a OptionalAddAction. */
-export function IsOptionalAddAction(value) {
-    return Guard.IsObject(value)
-        && Guard.HasPropertyKey(value, '~kind')
-        && Guard.HasPropertyKey(value, 'type')
-        && Guard.IsEqual(value['~kind'], 'OptionalAddAction')
-        && IsSchema(value.type);
-}
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a OptionalRemoveAction. */
-export function OptionalRemoveAction(type) {
-    return Memory.Create({ ['~kind']: 'OptionalRemoveAction' }, { type }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if this value is a OptionalRemoveAction. */
-export function IsOptionalRemoveAction(value) {
-    return Guard.IsObject(value)
-        && Guard.HasPropertyKey(value, '~kind')
-        && Guard.HasPropertyKey(value, 'type')
-        && Guard.IsEqual(value['~kind'], 'OptionalRemoveAction')
-        && IsSchema(value.type);
-}

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

@@ -1,19 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-/** Represents an operation to apply Readonly to a property. */
-export interface TReadonlyAddAction<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'ReadonlyAddAction';
-    type: Type;
-}
-/** Creates a ReadonlyAddAction. */
-export declare function ReadonlyAddAction<Type extends TSchema>(type: Type): TReadonlyAddAction<Type>;
-/** Returns true if this value is a ReadonlyAddAction. */
-export declare function IsReadonlyAddAction(value: unknown): value is TReadonlyAddAction;
-/** Represents an action to remove Readonly from a property. */
-export interface TReadonlyRemoveAction<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'ReadonlyRemoveAction';
-    type: Type;
-}
-/** Creates a ReadonlyRemoveAction. */
-export declare function ReadonlyRemoveAction<Type extends TSchema>(type: Type): TReadonlyRemoveAction<Type>;
-/** Returns true if this value is a ReadonlyRemoveAction. */
-export declare function IsReadonlyRemoveAction(value: unknown): value is TReadonlyRemoveAction;

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

@@ -1,40 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from '../types/schema.mjs';
-// ------------------------------------------------------------------
-// Action
-// ------------------------------------------------------------------
-/** Creates a ReadonlyAddAction. */
-export function ReadonlyAddAction(type) {
-    return Memory.Create({ ['~kind']: 'ReadonlyAddAction' }, { type }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if this value is a ReadonlyAddAction. */
-export function IsReadonlyAddAction(value) {
-    return Guard.IsObject(value)
-        && Guard.HasPropertyKey(value, '~kind')
-        && Guard.HasPropertyKey(value, 'type')
-        && Guard.IsEqual(value['~kind'], 'ReadonlyAddAction')
-        && IsSchema(value.type);
-}
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a ReadonlyRemoveAction. */
-export function ReadonlyRemoveAction(type) {
-    return Memory.Create({ ['~kind']: 'ReadonlyRemoveAction' }, { type }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if this value is a ReadonlyRemoveAction. */
-export function IsReadonlyRemoveAction(value) {
-    return Guard.IsObject(value)
-        && Guard.HasPropertyKey(value, '~kind')
-        && Guard.HasPropertyKey(value, 'type')
-        && Guard.IsEqual(value['~kind'], 'ReadonlyRemoveAction')
-        && IsSchema(value.type);
-}

package/node_modules/typebox/build/type/action/awaited.d.mts

@@ -1,15 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TAwaitedAction } from '../engine/awaited/instantiate.mjs';
-/** Creates a deferred Awaited action. */
-export type TAwaitedDeferred<Type extends TSchema> = (TDeferred<'Awaited', [Type]>);
-/** Creates a deferred Awaited action. */
-export declare function AwaitedDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaitedDeferred<Type>;
-/** Applies an Awaited action to a type. */
-export type TAwaited<Type extends TSchema> = (TAwaitedAction<Type>);
-/**
- * Applies an Awaited action to a type.
- *
- * @deprecated This action is being removed in the next version of TypeBox.
- */
-export declare function Awaited<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaited<Type>;

package/node_modules/typebox/build/type/action/awaited.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { AwaitedAction } from '../engine/awaited/instantiate.mjs';
-/** Creates a deferred Awaited action. */
-export function AwaitedDeferred(type, options = {}) {
-    return Deferred('Awaited', [type], options);
-}
-/**
- * Applies an Awaited action to a type.
- *
- * @deprecated This action is being removed in the next version of TypeBox.
- */
-export function Awaited(type, options = {}) {
-    return AwaitedAction(type, options);
-}

package/node_modules/typebox/build/type/action/options.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TOptionsAction } from '../engine/options/instantiate.mjs';
-/** Creates a deferred Options action. */
-export type TOptionsDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'Options', [Type, Options]>);
-/** Creates a deferred Options action. */
-export declare function OptionsDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsDeferred<Type, Options>;
-/** Applies an immediate Options action to the given type. */
-export type TOptions<Type extends TSchema, Options extends TSchema> = (Type & Options);
-/** Applies an immediate Options action to the given type. */
-export declare function Options<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TOptionsAction<Type, Options>;

package/node_modules/typebox/build/type/action/options.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { OptionsAction } from '../engine/options/instantiate.mjs';
-/** Creates a deferred Options action. */
-export function OptionsDeferred(type, options) {
-    return Deferred('Options', [type, options], {});
-}
-/** Applies an immediate Options action to the given type. */
-export function Options(type, options) {
-    return OptionsAction(type, options);
-}

package/node_modules/typebox/build/type/engine/awaited/instantiate.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
-import { type TPromise } from '../../types/promise.mjs';
-import { type TAwaitedDeferred } from '../../action/awaited.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TAwaitedOperation<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedOperation<Type> : Type);
-export type TAwaitedAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TAwaitedOperation<Type> : TAwaitedDeferred<Type>> = Result;
-export declare function AwaitedAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAwaitedAction<Type>;
-export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
-export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/awaited/instantiate.mjs

@@ -1,20 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../../system/memory/index.mjs';
-import { IsPromise } from '../../types/promise.mjs';
-import { AwaitedDeferred } from '../../action/awaited.mjs';
-import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function AwaitedOperation(type) {
-    return (IsPromise(type)
-        ? AwaitedOperation(type.item)
-        : type);
-}
-export function AwaitedAction(type, options) {
-    const result = CanInstantiate([type])
-        ? Memory.Update(AwaitedOperation(type), {}, options)
-        : AwaitedDeferred(type, options);
-    return result;
-}
-export function AwaitedInstantiate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return AwaitedAction(instantiatedType, options);
-}

package/node_modules/typebox/build/type/engine/enum/enum_to_union.d.mts

@@ -1,14 +0,0 @@
-import { type TSchema } from '../../types/schema.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
-import { type TNull } from '../../types/null.mjs';
-import { type TNever } from '../../types/never.mjs';
-type TFromEnumValue<Value extends TEnumValue, Result extends TSchema = Value extends string | number ? TLiteral<Value> : Value extends null ? TNull : TNever> = Result;
-export type TEnumValuesToVariants<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEnumValuesToVariants<Right, [...Result, TFromEnumValue<Left>]> : Result);
-export declare function EnumValuesToVariants<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToVariants<Values>;
-export type TEnumValuesToUnion<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Results extends TSchema = TUnion<Variants>> = Results;
-export declare function EnumValuesToUnion<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToUnion<Values>;
-export type TEnumToUnion<Type extends TEnum, Result extends TSchema = TEnumValuesToUnion<Type['enum']>> = Result;
-export declare function EnumToUnion<Type extends TEnum>(type: Type): TEnumToUnion<Type>;
-export {};

package/node_modules/typebox/build/type/engine/enum/enum_to_union.mjs

@@ -1,24 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../../guard/index.mjs';
-import { Union } from '../../types/union.mjs';
-import { Literal } from '../../types/literal.mjs';
-import { Null } from '../../types/null.mjs';
-import { Never } from '../../types/never.mjs';
-function FromEnumValue(value) {
-    return (Guard.IsString(value) || Guard.IsNumber(value) ? Literal(value) :
-        Guard.IsNull(value) ? Null() :
-            Never());
-}
-export function EnumValuesToVariants(values) {
-    const result = values.map(value => FromEnumValue(value));
-    return result;
-}
-export function EnumValuesToUnion(values) {
-    const variants = EnumValuesToVariants(values);
-    const result = Union(variants);
-    return result;
-}
-export function EnumToUnion(type) {
-    const result = EnumValuesToUnion(type.enum);
-    return result;
-}

package/node_modules/typebox/build/type/engine/options/index.d.mts

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

package/node_modules/typebox/build/type/engine/options/index.mjs

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

package/node_modules/typebox/build/type/engine/options/instantiate.d.mts

@@ -1,8 +0,0 @@
-import { type TProperties } from '../../types/properties.mjs';
-import { type TSchema } from '../../types/schema.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TOptionsDeferred, type TOptions } from '../../action/options.mjs';
-export type TOptionsAction<Type extends TSchema, Options extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TOptions<Type, Options> : TOptionsDeferred<Type, Options>> = Result;
-export declare function OptionsAction<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsAction<Type, Options>;
-export type TOptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TOptionsAction<InstantiatedType, Options>;
-export declare function OptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema>(context: Context, state: State, type: Type, options: Options): TOptionsInstantiate<Context, State, Type, Options>;

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

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TAsyncIterator } from '../types/async_iterator.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAsyncIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TAsyncIterator<Left>, Right>);
-export declare function ExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAsyncIterator<Inferred, Left, Right>;

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

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { AsyncIterator, IsAsyncIterator } from '../types/async_iterator.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsAsyncIterator(inferred, left, right) {
-    return (IsAsyncIterator(right)
-        ? ExtendsLeft(inferred, left, right.iteratorItems)
-        : ExtendsRight(inferred, AsyncIterator(left), right));
-}

package/node_modules/typebox/build/type/extends/iterator.d.mts

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TIterator } from '../types/iterator.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TIterator<Left>, Right>);
-export declare function ExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIterator<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/iterator.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Iterator, IsIterator } from '../types/iterator.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsIterator(inferred, left, right) {
-    return (IsIterator(right)
-        ? ExtendsLeft(inferred, left, right.iteratorItems)
-        : ExtendsRight(inferred, Iterator(left), right));
-}

package/node_modules/typebox/build/type/extends/promise.d.mts

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TPromise } from '../types/promise.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TPromise<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TPromise<Left>, Right>);
-export declare function ExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsPromise<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/promise.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Promise, IsPromise } from '../types/promise.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsPromise(inferred, left, right) {
-    return (IsPromise(right)
-        ? ExtendsLeft(inferred, left, right.item)
-        : ExtendsRight(inferred, Promise(left), right));
-}

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

@@ -1,20 +0,0 @@
-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

@@ -1,28 +0,0 @@
-// 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

@@ -1,50 +0,0 @@
-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;

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

@@ -1,84 +0,0 @@
-// deno-fmt-ignore-file
-import { Settings } from '../../system/settings/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Type.Base<...>
-// ------------------------------------------------------------------
-function BaseProperty(value) {
-    return {
-        enumerable: Settings.Get().enumerableKind,
-        writable: false,
-        configurable: false,
-        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 class Base {
-    constructor() {
-        globalThis.Object.defineProperty(this, '~kind', BaseProperty('Base'));
-        globalThis.Object.defineProperty(this, '~guard', BaseProperty({
-            check: (value) => this.Check(value),
-            errors: (value) => this.Errors(value)
-        }));
-    }
-    /** Checks a value or returns false if invalid */
-    Check(_value) {
-        return true;
-    }
-    /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(_value) {
-        return [];
-    }
-    /** Converts a value into this type */
-    Convert(value) {
-        return value;
-    }
-    /** Cleans a value according to this type */
-    Clean(value) {
-        return value;
-    }
-    /** Returns a default value for this type */
-    Default(value) {
-        return value;
-    }
-    /** Creates a new instance of this type */
-    Create() {
-        throw new Error('Create not implemented');
-    }
-    /** Clones this type  */
-    Clone() {
-        throw Error('Clone not implemented');
-    }
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a Base type. */
-export function IsBase(value) {
-    return IsKind(value, 'Base');
-}

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

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

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

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

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

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

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

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

package/node_modules/typebox/build/value/clean/from_base.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, Base } from '../../type/index.mjs';
-export declare function FromBase(_context: TProperties, type: Base, value: unknown): unknown;

package/node_modules/typebox/build/value/clean/from_base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type, value) {
-    return type.Clean(value);
-}

package/node_modules/typebox/build/value/convert/from_base.d.mts

@@ -1,2 +0,0 @@
-import type { Base, TProperties } from '../../type/index.mjs';
-export declare function FromBase(_context: TProperties, type: Base, value: unknown): unknown;

package/node_modules/typebox/build/value/convert/from_base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type, value) {
-    return type.Convert(value);
-}

package/node_modules/typebox/build/value/create/from_async_iterator.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TAsyncIterator } from '../../type/index.mjs';
-export declare function FromAsyncIterator(_context: TProperties, _type: TAsyncIterator): unknown;