@openclaw/google-meet 2026.7.1-beta.2 → 2026.7.1-beta.5

package/node_modules/typebox/build/system/locale/hi_IN.mjs

@@ -33,7 +33,6 @@ export function hi_IN(error) {
         case 'unevaluatedItems': return 'में अप्रयुक्त आइटम नहीं होने चाहिए';
         case 'unevaluatedProperties': return 'में अप्रयुक्त गुण नहीं होने चाहिए';
         case 'uniqueItems': return `में डुप्लिकेट आइटम नहीं होने चाहिए`;
-        case '~guard': return `चेक फ़ंक्शन से मेल खाना चाहिए`;
         case '~refine': return error.params.message;
         default: return 'एक अज्ञात सत्यापन त्रुटि हुई';
     }

package/node_modules/typebox/build/system/locale/hu_HU.mjs

@@ -33,7 +33,6 @@ export function hu_HU(error) {
         case 'unevaluatedItems': return 'nem lehetnek nem értékelt elemei';
         case 'unevaluatedProperties': return 'nem lehetnek nem értékelt tulajdonságai';
         case 'uniqueItems': return `nem lehetnek ismétlődő elemei`;
-        case '~guard': return `meg kell felelnie az ellenőrző függvénynek`;
         case '~refine': return error.params.message;
         default: return 'ismeretlen validációs hiba történt';
     }

package/node_modules/typebox/build/system/locale/id_ID.mjs

@@ -33,7 +33,6 @@ export function id_ID(error) {
         case 'unevaluatedItems': return 'tidak boleh memiliki item yang belum dievaluasi';
         case 'unevaluatedProperties': return 'tidak boleh memiliki properti yang belum dievaluasi';
         case 'uniqueItems': return `tidak boleh memiliki item duplikat`;
-        case '~guard': return `harus sesuai dengan fungsi pemeriksaan`;
         case '~refine': return error.params.message;
         default: return 'terjadi kesalahan validasi yang tidak diketahui';
     }

package/node_modules/typebox/build/system/locale/it_IT.mjs

@@ -33,7 +33,6 @@ export function it_IT(error) {
         case 'unevaluatedItems': return 'non deve avere elementi non valutati';
         case 'unevaluatedProperties': return 'non deve avere proprietà non valutate';
         case 'uniqueItems': return `non deve avere elementi duplicati`;
-        case '~guard': return `deve corrispondere alla funzione di controllo`;
         case '~refine': return error.params.message;
         default: return 'si è verificato un errore di validazione sconosciuto';
     }

package/node_modules/typebox/build/system/locale/ja_JP.mjs

@@ -33,7 +33,6 @@ export function ja_JP(error) {
         case 'unevaluatedItems': return '未評価のアイテムを持つことはできません';
         case 'unevaluatedProperties': return '未評価のプロパティを持つことはできません';
         case 'uniqueItems': return `重複するアイテムを持つことはできません`;
-        case '~guard': return `チェック関数と一致する必要があります`;
         case '~refine': return error.params.message;
         default: return '不明なバリデーションエラーが発生しました';
     }

package/node_modules/typebox/build/system/locale/ko_KR.mjs

@@ -33,7 +33,6 @@ export function ko_KR(error) {
         case 'unevaluatedItems': return '평가되지 않은 항목을 가질 수 없습니다';
         case 'unevaluatedProperties': return '평가되지 않은 속성을 가질 수 없습니다';
         case 'uniqueItems': return `중복 항목을 가질 수 없습니다`;
-        case '~guard': return `체크 함수와 일치해야 합니다`;
         case '~refine': return error.params.message;
         default: return '알 수 없는 유효성 검사 오류가 발생했습니다';
     }

package/node_modules/typebox/build/system/locale/ms_MY.mjs

@@ -33,7 +33,6 @@ export function ms_MY(error) {
         case 'unevaluatedItems': return 'tidak boleh mempunyai item yang tidak dinilai';
         case 'unevaluatedProperties': return 'tidak boleh mempunyai sifat yang tidak dinilai';
         case 'uniqueItems': return `tidak boleh mempunyai item pendua`;
-        case '~guard': return `mestilah sepadan dengan fungsi semak`;
         case '~refine': return error.params.message;
         default: return 'ralat pengesahan yang tidak diketahui berlaku';
     }

package/node_modules/typebox/build/system/locale/nl_NL.mjs

@@ -33,7 +33,6 @@ export function nl_NL(error) {
         case 'unevaluatedItems': return 'mag geen onbeoordeelde items hebben';
         case 'unevaluatedProperties': return 'mag geen onbeoordeelde eigenschappen hebben';
         case 'uniqueItems': return `mag geen dubbele items hebben`;
-        case '~guard': return `moet overeenkomen met de controlefunctie`;
         case '~refine': return error.params.message;
         default: return 'er is een onbekende validatiefout opgetreden';
     }

package/node_modules/typebox/build/system/locale/pl_PL.mjs

@@ -33,7 +33,6 @@ export function pl_PL(error) {
         case 'unevaluatedItems': return 'nie może mieć nieewaluowanych elementów';
         case 'unevaluatedProperties': return 'nie może mieć nieewaluowanych właściwości';
         case 'uniqueItems': return `nie może zawierać zduplikowanych elementów`;
-        case '~guard': return `musi pasować do funkcji sprawdzającej`;
         case '~refine': return error.params.message;
         default: return 'wystąpił nieznany błąd walidacji';
     }

package/node_modules/typebox/build/system/locale/pt_BR.mjs

@@ -33,7 +33,6 @@ export function pt_BR(error) {
         case 'unevaluatedItems': return 'não deve ter itens não avaliados';
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
-        case '~guard': return `deve corresponder à função de verificação`;
         case '~refine': return error.params.message;
         default: return 'ocorreu um erro de validação desconhecido';
     }

package/node_modules/typebox/build/system/locale/pt_PT.mjs

@@ -33,7 +33,6 @@ export function pt_PT(error) {
         case 'unevaluatedItems': return 'não deve ter itens não avaliados';
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
-        case '~guard': return `deve corresponder à função de verificação`;
         case '~refine': return error.params.message;
         default: return 'ocorreu um erro de validação desconhecido';
     }

package/node_modules/typebox/build/system/locale/ro_RO.mjs

@@ -33,7 +33,6 @@ export function ro_RO(error) {
         case 'unevaluatedItems': return 'nu trebuie să aibă elemente neevaluate';
         case 'unevaluatedProperties': return 'nu trebuie să aibă proprietăți neevaluate';
         case 'uniqueItems': return `nu trebuie să aibă elemente duplicate`;
-        case '~guard': return `trebuie să corespundă funcției de verificare`;
         case '~refine': return error.params.message;
         default: return 'a apărut o eroare de validare necunoscută';
     }

package/node_modules/typebox/build/system/locale/ru_RU.mjs

@@ -33,7 +33,6 @@ export function ru_RU(error) {
         case 'unevaluatedItems': return 'не должно быть нерассмотренных элементов';
         case 'unevaluatedProperties': return 'не должно быть нерассмотренных свойств';
         case 'uniqueItems': return `не должно быть повторяющихся элементов`;
-        case '~guard': return `должно соответствовать проверочной функции`;
         case '~refine': return error.params.message;
         default: return 'произошла неизвестная ошибка валидации';
     }

package/node_modules/typebox/build/system/locale/sv_SE.mjs

@@ -33,7 +33,6 @@ export function sv_SE(error) {
         case 'unevaluatedItems': return 'får inte ha oidentifierade objekt';
         case 'unevaluatedProperties': return 'får inte ha oidentifierade egenskaper';
         case 'uniqueItems': return `får inte ha dubbletter`;
-        case '~guard': return `måste matcha kontrollfunktionen`;
         case '~refine': return error.params.message;
         default: return 'ett okänt valideringsfel uppstod';
     }

package/node_modules/typebox/build/system/locale/sw_TZ.mjs

@@ -33,7 +33,6 @@ export function sw_TZ(error) {
         case 'unevaluatedItems': return 'haipaswi kuwa na vitu visivyotathminiwa';
         case 'unevaluatedProperties': return 'haipaswi kuwa na sifa zisizotathminiwa';
         case 'uniqueItems': return `haipaswi kuwa na vitu vilivyofanana`;
-        case '~guard': return `inapaswa kulingana na kipengele cha ukaguzi`;
         case '~refine': return error.params.message;
         default: return 'hitilafu isiyojulikana ya uthibitishaji imetokea';
     }

package/node_modules/typebox/build/system/locale/th_TH.mjs

@@ -33,7 +33,6 @@ export function th_TH(error) {
         case 'unevaluatedItems': return 'ต้องไม่มีรายการที่ยังไม่ได้ประเมิน';
         case 'unevaluatedProperties': return 'ต้องไม่มีคุณสมบัติที่ยังไม่ได้ประเมิน';
         case 'uniqueItems': return `ต้องไม่มีรายการที่ซ้ำกัน`;
-        case '~guard': return `ต้องตรงกับฟังก์ชันตรวจสอบ`;
         case '~refine': return error.params.message;
         default: return 'เกิดข้อผิดพลาดในการตรวจสอบที่ไม่รู้จัก';
     }

package/node_modules/typebox/build/system/locale/tr_TR.mjs

@@ -33,7 +33,6 @@ export function tr_TR(error) {
         case 'unevaluatedItems': return 'değerlendirilmemiş öğelere sahip olmamalıdır';
         case 'unevaluatedProperties': return 'değerlendirilmemiş özelliklere sahip olmamalıdır';
         case 'uniqueItems': return `yinelenen öğelere sahip olmamalıdır`;
-        case '~guard': return `kontrol fonksiyonuyla eşleşmelidir`;
         case '~refine': return error.params.message;
         default: return 'bilinmeyen bir doğrulama hatası oluştu';
     }

package/node_modules/typebox/build/system/locale/uk_UA.mjs

@@ -33,7 +33,6 @@ export function uk_UA(error) {
         case 'unevaluatedItems': return 'не повинно мати неперевірених елементів';
         case 'unevaluatedProperties': return 'не повинно мати неперевірених властивостей';
         case 'uniqueItems': return `не повинно мати повторюваних елементів`;
-        case '~guard': return `повинно відповідати функції перевірки`;
         case '~refine': return error.params.message;
         default: return 'виникла невідома помилка валідації';
     }

package/node_modules/typebox/build/system/locale/ur_PK.mjs

@@ -33,7 +33,6 @@ export function ur_PK(error) {
         case 'unevaluatedItems': return 'غیر تشخیص شدہ آئٹمز نہیں ہونے چاہئیں';
         case 'unevaluatedProperties': return 'غیر تشخیص شدہ خصوصیات نہیں ہونی چاہئیں';
         case 'uniqueItems': return `ڈپلیکیٹ آئٹمز نہیں ہونے چاہئیں`;
-        case '~guard': return `چیک فنکشن سے مطابقت ہونی چاہیے`;
         case '~refine': return error.params.message;
         default: return 'تصدیق میں ایک نامعلوم خرابی پیش آئی';
     }

package/node_modules/typebox/build/system/locale/vi_VN.mjs

@@ -33,7 +33,6 @@ export function vi_VN(error) {
         case 'unevaluatedItems': return 'không được có các mục chưa được đánh giá';
         case 'unevaluatedProperties': return 'không được có các thuộc tính chưa được đánh giá';
         case 'uniqueItems': return `không được có các mục trùng lặp`;
-        case '~guard': return `phải khớp với hàm kiểm tra`;
         case '~refine': return error.params.message;
         default: return 'đã xảy ra lỗi xác thực không xác định';
     }

package/node_modules/typebox/build/system/locale/yo_NG.mjs

@@ -33,7 +33,6 @@ export function yo_NG(error) {
         case 'unevaluatedItems': return 'ko gbọdọ ni awọn ohun ti ko ṣe iṣiro';
         case 'unevaluatedProperties': return 'ko gbọdọ ni awọn ohun-ini ti ko ṣe iṣiro';
         case 'uniqueItems': return `ko gbọdọ ni awọn ohun elo ẹda`;
-        case '~guard': return `gbogbo yẹ ki o ba iṣẹ́ ṣàyẹ̀wò mu`;
         case '~refine': return error.params.message;
         default: return 'aṣiṣe ijẹrisi aimọ waye';
     }

package/node_modules/typebox/build/system/locale/zh_Hans.mjs

@@ -33,7 +33,6 @@ export function zh_Hans(error) {
         case 'unevaluatedItems': return '不得有未评估的项';
         case 'unevaluatedProperties': return '不得有未评估的属性';
         case 'uniqueItems': return `不得有重复项`;
-        case '~guard': return `必须与检查函数匹配`;
         case '~refine': return error.params.message;
         default: return '发生未知验证错误';
     }

package/node_modules/typebox/build/system/locale/zh_Hant.mjs

@@ -33,7 +33,6 @@ export function zh_Hant(error) {
         case 'unevaluatedItems': return '不得有未評估的項目';
         case 'unevaluatedProperties': return '不得有未評估的屬性';
         case 'uniqueItems': return `不得有重複項目`;
-        case '~guard': return `必須與檢查函數匹配`;
         case '~refine': return error.params.message;
         default: return '發生未知驗證錯誤';
     }

package/node_modules/typebox/build/system/memory/clone.d.mts

@@ -1,6 +1,5 @@
 /**
- * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
- * properties from the source value. This is to ensure cloned types retain discriminable
- * hidden properties.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export declare function Clone<Value extends unknown = unknown>(value: Value): Value;

package/node_modules/typebox/build/system/memory/clone.mjs

@@ -1,28 +1,33 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 // ------------------------------------------------------------------
-// Guard
+// ClassInstance
+//
+// TypeBox does not clone arbitrary class instances. Class instances
+// cannot be safely cloned without potentially breaking private
+// members of the instance.
+//
 // ------------------------------------------------------------------
-function IsGuard(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~guard');
-}
-function FromGuard(value) {
-    return value; // non-clonable
+function FromClassInstance(value) {
+    return value; // atomic
 }
 // ------------------------------------------------------------------
-// Array
+// TypeObject
+//
+// Types have non-enumerable properties that MUST be preserved on Clone. 
+// The following is the optimal path for TypeBox types.
 // ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((value) => FromValue(value));
+function IsTypeObject(value) {
+    return (Guard.HasPropertyKey(value, '~kind') ||
+        Guard.HasPropertyKey(value, '~unsafe'));
 }
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
+function FromTypeObject(value) {
     const result = {};
     const descriptors = Object.getOwnPropertyDescriptors(value);
     for (const key of Object.keys(descriptors)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         const descriptor = descriptors[key];
         if (Guard.HasPropertyKey(descriptor, 'value')) {
             Object.defineProperty(result, key, { ...descriptor, value: FromValue(descriptor.value) });
@@ -31,31 +36,73 @@ function FromObject(value) {
     return result;
 }
 // ------------------------------------------------------------------
+// PlainObject
+// ------------------------------------------------------------------
+function FromPlainObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        result[key] = FromValue(value[key]);
+    }
+    for (const key of Guard.Symbols(value)) {
+        result[key] = FromValue(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
+        IsTypeObject(value) ? FromTypeObject(value) :
+            FromPlainObject(value));
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => FromValue(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
 // RegExp
 // ------------------------------------------------------------------
 function FromRegExp(value) {
     return new RegExp(value.source, value.flags);
 }
 // ------------------------------------------------------------------
-// RegExp
+// Map
 // ------------------------------------------------------------------
-function FromUnknown(value) {
-    return value;
+function FromMap(value) {
+    return new Map(FromValue([...value.entries()]));
 }
 // ------------------------------------------------------------------
-// Value
+// Set
 // ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(FromValue([...value.values()]));
+}
 function FromValue(value) {
-    return (value instanceof RegExp ? FromRegExp(value) :
-        IsGuard(value) ? FromGuard(value) :
-            Guard.IsArray(value) ? FromArray(value) :
-                Guard.IsObject(value) ? FromObject(value) :
-                    FromUnknown(value));
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+            GlobalsGuard.IsMap(value) ? FromMap(value) :
+                GlobalsGuard.IsSet(value) ? FromSet(value) :
+                    Guard.IsArray(value) ? FromArray(value) :
+                        Guard.IsObject(value) ? FromObject(value) :
+                            value);
 }
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
 /**
- * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
- * properties from the source value. This is to ensure cloned types retain discriminable
- * hidden properties.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export function Clone(value) {
     Metrics.clone += 1;

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -3,6 +3,7 @@ export interface TSettings {
      * Determines whether types should be instantiated as immutable using `Object.freeze(...)`.
      * This helps prevent unintended schema mutation. Enabling this option introduces a slight
      * performance overhead during instantiation.
+     *
      * @default false
      */
     immutableTypes: boolean;
@@ -11,6 +12,7 @@ export interface TSettings {
      * performs exhaustive checks to gather diagnostics for invalid values, which can result in
      * excessive buffering for large or complex types. This setting limits the number of buffered
      * errors and acts as a safeguard against potential denial-of-service (DoS) attacks.
+     *
      * @default 8
      */
     maxErrors: number;
@@ -20,6 +22,7 @@ export interface TSettings {
      * generated code. If evaluation is not permitted, it falls back to dynamic checking. Setting
      * this to `false` disables evaluation entirely, which may be desirable in applications that
      * restrict runtime code evaluation, regardless of Content Security Policy (CSP).
+     *
      * @default true
      */
     useAcceleration: boolean;
@@ -30,11 +33,13 @@ export interface TSettings {
      * TypeScript semantics to remain consistent with the language. This option is provided to align
      * runtime check semantics with projects that configure 'exactOptionalPropertyTypes: true' in
      * tsconfig.json.
+     *
      * @default false
      */
     exactOptionalPropertyTypes: boolean;
     /**
      * Controls whether internal compositor properties (`~kind`, `~readonly`, `~optional`) are enumerable.
+     *
      * @default false
      */
     enumerableKind: boolean;
@@ -44,9 +49,19 @@ export interface TSettings {
      * the value, followed by a subsequent `Assert`. Enabling this option may incur significant performance
      * overhead for invalid values. It is recommended to keep this disabled in performance-sensitive
      * applications.
+     *
      * @default false
      */
     correctiveParse: boolean;
+    /**
+     * Controls whether TypeBox sorts Union variants by specificity (narrowest first) for operations
+     * that require deterministic value matching, such as Clean, Decode, and Encode. When enabled,
+     * more specific types (e.g. Literal) always take precedence over broader types (e.g. String),
+     * regardless of the order variants are declared.
+     *
+     * @default true
+     */
+    unionPrioritySort: boolean;
 }
 /** Resets system settings to defaults */
 export declare function Reset(): void;

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -6,7 +6,8 @@ const settings = {
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
     enumerableKind: false,
-    correctiveParse: false
+    correctiveParse: false,
+    unionPrioritySort: true
 };
 /** Resets system settings to defaults */
 export function Reset() {
@@ -16,6 +17,7 @@ export function Reset() {
     settings.exactOptionalPropertyTypes = false;
     settings.enumerableKind = false;
     settings.correctiveParse = false;
+    settings.unionPrioritySort = true;
 }
 /** Sets system settings */
 export function Set(options) {

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
+/** Creates a deferred AddImmutable action. */
+export type TAddImmutableDeferred<Type extends TSchema> = (TDeferred<'AddImmutable', [Type]>);
+/** Creates a deferred AddImmutable action. */
+export declare function AddImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutableDeferred<Type>;
+/** Applies an AddImmutable action to a type. */
+export type TAddImmutable<Type extends TSchema> = (TAddImmutableAction<Type>);
+/** Applies an AddImmutable action to a type. */
+export declare function AddImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutable<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
+/** Creates a deferred AddImmutable action. */
+export function AddImmutableDeferred(type, options = {}) {
+    return Deferred('AddImmutable', [type], options);
+}
+/** Applies an AddImmutable action to a type. */
+export function AddImmutable(type, options = {}) {
+    return AddImmutableAction(type, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddOptionalAction } from '../engine/optional/instantiate_add.mjs';
+/** Creates a deferred AddOptional action. */
+export type TAddOptionalDeferred<Type extends TSchema> = (TDeferred<'AddOptional', [Type]>);
+/** Creates a deferred AddOptional action. */
+export declare function AddOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptionalDeferred<Type>;
+/** Applies an AddOptional action to a type. */
+export type TAddOptional<Type extends TSchema> = (TAddOptionalAction<Type>);
+/** Applies an AddOptional action to a type. */
+export declare function AddOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptional<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddOptionalAction } from '../engine/optional/instantiate_add.mjs';
+/** Creates a deferred AddOptional action. */
+export function AddOptionalDeferred(type, options = {}) {
+    return Deferred('AddOptional', [type], options);
+}
+/** Applies an AddOptional action to a type. */
+export function AddOptional(type, options = {}) {
+    return AddOptionalAction(type, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
+/** Creates a deferred AddReadonly action. */
+export type TAddReadonlyDeferred<Type extends TSchema> = (TDeferred<'AddReadonly', [Type]>);
+/** Creates a deferred AddReadonly action. */
+export declare function AddReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonlyDeferred<Type>;
+/** Applies an AddReadonly action to a type. */
+export type TAddReadonly<Type extends TSchema> = (TAddReadonlyAction<Type>);
+/** Applies an AddReadonly action to a type. */
+export declare function AddReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonly<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
+/** Creates a deferred AddReadonly action. */
+export function AddReadonlyDeferred(type, options = {}) {
+    return Deferred('AddReadonly', [type], options);
+}
+/** Applies an AddReadonly action to a type. */
+export function AddReadonly(type, options = {}) {
+    return AddReadonlyAction(type, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
+/** Creates a deferred RemoveImmutable action. */
+export type TRemoveImmutableDeferred<Type extends TSchema> = (TDeferred<'RemoveImmutable', [Type]>);
+/** Creates a deferred RemoveImmutable action. */
+export declare function RemoveImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutableDeferred<Type>;
+/** Applies an RemoveImmutable action to a type. */
+export type TRemoveImmutable<Type extends TSchema> = (TRemoveImmutableAction<Type>);
+/** Applies an RemoveImmutable action to a type. */
+export declare function RemoveImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutable<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
+/** Creates a deferred RemoveImmutable action. */
+export function RemoveImmutableDeferred(type, options = {}) {
+    return Deferred('RemoveImmutable', [type], options);
+}
+/** Applies an RemoveImmutable action to a type. */
+export function RemoveImmutable(type, options = {}) {
+    return RemoveImmutableAction(type, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
+/** Creates a deferred RemoveOptional action. */
+export type TRemoveOptionalDeferred<Type extends TSchema> = (TDeferred<'RemoveOptional', [Type]>);
+/** Creates a deferred RemoveOptional action. */
+export declare function RemoveOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptionalDeferred<Type>;
+/** Applies an RemoveOptional action to a type. */
+export type TRemoveOptional<Type extends TSchema> = (TRemoveOptionalAction<Type>);
+/** Applies an RemoveOptional action to a type. */
+export declare function RemoveOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptional<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
+/** Creates a deferred RemoveOptional action. */
+export function RemoveOptionalDeferred(type, options = {}) {
+    return Deferred('RemoveOptional', [type], options);
+}
+/** Applies an RemoveOptional action to a type. */
+export function RemoveOptional(type, options = {}) {
+    return RemoveOptionalAction(type, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export type TRemoveReadonlyDeferred<Type extends TSchema> = (TDeferred<'RemoveReadonly', [Type]>);
+/** Creates a deferred RemoveReadonly action. */
+export declare function RemoveReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonlyDeferred<Type>;
+/** Applies an RemoveReadonly action to a type. */
+export type TRemoveReadonly<Type extends TSchema> = (TRemoveReadonlyAction<Type>);
+/** Applies an RemoveReadonly action to a type. */
+export declare function RemoveReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonly<Type>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export function RemoveReadonlyDeferred(type, options = {}) {
+    return Deferred('RemoveReadonly', [type], options);
+}
+/** Applies an RemoveReadonly action to a type. */
+export function RemoveReadonly(type, options = {}) {
+    return RemoveReadonlyAction(type, options);
+}

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

@@ -1,13 +1,12 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Creates a deferred Conditional action. */
 export type TConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TDeferred<'Conditional', [Left, Right, True, False]>);
 /** Creates a deferred Conditional action. */
 export declare function ConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditionalDeferred<Left, Right, True, False>;
 /** Applies a Conditional action to the given types. */
-export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, {
-    callstack: [];
-}, Left, Right, True, False>);
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, TState<[], []>, Left, Right, True, False>);
 /** Applies a Conditional action to the given types. */
 export declare function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditional<Left, Right, True, False>;