@openclaw/msteams 2026.7.1-beta.1 → 2026.7.1-beta.4

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;

package/node_modules/typebox/build/value/create/from_async_iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-async function* CreateAsyncIterator() { }
-export function FromAsyncIterator(_context, _type) {
-    return CreateAsyncIterator();
-}

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

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

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

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

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

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

package/node_modules/typebox/build/value/create/from_iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-function* CreateIterator() { }
-export function FromIterator(_context, _type) {
-    return CreateIterator();
-}

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

@@ -1,2 +0,0 @@
-import type { TProperties, TPromise } from '../../type/index.mjs';
-export declare function FromPromise(context: TProperties, type: TPromise): unknown;

package/node_modules/typebox/build/value/create/from_promise.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-import { FromType } from './from_type.mjs';
-export function FromPromise(context, type) {
-    return Promise.resolve(FromType(context, type.item));
-}

package/node_modules/typebox/build/value/default/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/default/from_base.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file 
-export function FromBase(context, type, value) {
-    return type.Default(value);
-}

package/node_modules/typebox/build/value/mutate/error.d.mts

@@ -1,3 +0,0 @@
-export declare class MutateError extends Error {
-    constructor(message: string);
-}

package/node_modules/typebox/build/value/mutate/error.mjs

@@ -1,6 +0,0 @@
-// deno-fmt-ignore-file
-export class MutateError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}

package/node_modules/typebox/build/value/mutate/from_array.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromArray(root: TMutable, path: string, current: unknown, next: unknown[]): void;

package/node_modules/typebox/build/value/mutate/from_array.mjs

@@ -1,16 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { FromValue } from './from_value.mjs';
-export function FromArray(root, path, current, next) {
-    if (!Guard.IsArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            FromValue(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}

package/node_modules/typebox/build/value/mutate/from_object.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromObject(root: TMutable, path: string, current: unknown, next: Record<string, unknown>): void;

package/node_modules/typebox/build/value/mutate/from_object.mjs

@@ -1,40 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { FromValue } from './from_value.mjs';
-// ------------------------------------------------------------------
-// AssertKey
-// ------------------------------------------------------------------
-function AssertKey(key) {
-    if (Guard.IsUnsafePropertyKey(key))
-        throw Error('Attempted to Mutate with unsafe property key');
-}
-// ------------------------------------------------------------------
-// AssertKey
-// ------------------------------------------------------------------
-export function FromObject(root, path, current, next) {
-    if (!Guard.IsObjectNotArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        const currentKeys = Guard.Keys(current);
-        const nextKeys = Guard.Keys(next);
-        for (const currentKey of currentKeys) {
-            AssertKey(currentKey);
-            if (!nextKeys.includes(currentKey)) {
-                delete current[currentKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            AssertKey(nextKey);
-            if (!currentKeys.includes(nextKey)) {
-                current[nextKey] = next[nextKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            AssertKey(nextKey);
-            FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}

package/node_modules/typebox/build/value/mutate/from_unknown.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromUnknown(root: TMutable, path: string, current: unknown, next: unknown): void;

package/node_modules/typebox/build/value/mutate/from_unknown.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { Pointer } from '../pointer/index.mjs';
-export function FromUnknown(root, path, current, next) {
-    if (current === next)
-        return;
-    Pointer.Set(root, path, next);
-}

package/node_modules/typebox/build/value/mutate/from_value.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromValue(root: TMutable, path: string, current: unknown, next: unknown): void;

package/node_modules/typebox/build/value/mutate/from_value.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromArray } from './from_array.mjs';
-import { FromObject } from './from_object.mjs';
-import { FromUnknown } from './from_unknown.mjs';
-export function FromValue(root, path, current, next) {
-    if (Guard.IsArray(next))
-        return FromArray(root, path, current, next);
-    if (Guard.IsObject(next))
-        return FromObject(root, path, current, next);
-    return FromUnknown(root, path, current, next);
-}

package/node_modules/typebox/build/value/mutate/index.d.mts

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

package/node_modules/typebox/build/value/mutate/index.mjs

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

package/node_modules/typebox/build/value/mutate/mutate.d.mts

@@ -1,11 +0,0 @@
-export type TMutable = {
-    [key: string]: unknown;
-} | unknown[];
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- *
- * @deprecated This function is being removed in the next version but will be retained as a reference under examples.
- */
-export declare function Mutate(current: TMutable, next: TMutable): void;

package/node_modules/typebox/build/value/mutate/mutate.mjs

@@ -1,41 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-import { MutateError } from './error.mjs';
-import { FromValue } from './from_value.mjs';
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return GlobalsGuard.IsTypeArray(value)
-        || GlobalsGuard.IsDate(value)
-        || GlobalsGuard.IsMap(value)
-        || GlobalsGuard.IsSet(value)
-        || Guard.IsNumber(value)
-        || Guard.IsString(value)
-        || Guard.IsBoolean(value)
-        || Guard.IsSymbol(value);
-}
-// ------------------------------------------------------------------
-// IsTrueObject
-// ------------------------------------------------------------------
-function IsMismatchedValue(left, right) {
-    return ((Guard.IsObjectNotArray(left) && Guard.IsArray(right)) ||
-        (Guard.IsArray(left) && Guard.IsObjectNotArray(right)));
-}
-// ------------------------------------------------------------------
-// Mutate
-// ------------------------------------------------------------------
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- *
- * @deprecated This function is being removed in the next version but will be retained as a reference under examples.
- */
-export function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new MutateError('Only object and array types can be mutated at the root level');
-    if (IsMismatchedValue(current, next))
-        throw new MutateError('Cannot assign due type mismatch of assignable values');
-    FromValue(current, '', current, next);
-}

package/node_modules/typebox/build/value/repair/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/repair/from_base.mjs

@@ -1,8 +0,0 @@
-// deno-fmt-ignore-file
-import { FromUnknown } from './from_unknown.mjs';
-// ------------------------------------------------------------------
-// FromBase
-// ------------------------------------------------------------------
-export function FromBase(context, type, value) {
-    return FromUnknown(context, type, value);
-}

package/node_modules/uuid/LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2010-2020 Robert Kieffer and other contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.