@fkn/lib 0.9.53 → 0.9.55

package/{api-mHRuM_Sd.d.ts → api-BSpQkgnM.d.ts}

@@ -1,4 +1,4 @@
-import { D as IpFamily, Ft as UdpDatagram, H as ProxyFetchInput, Ht as WriteData, I as PackagesErrorCode, It as UdpSocketOptions, J as RoomClaimOptions, K as Resolvers, N as OverlayState, Nt as TcpSocketOptions, P as PackageQuery, Q as RoomEvent, R as PickOptions, T as InstallOptions, Tt as StoragePutWire, V as ProxyFetchInit, a as AccountChange, at as RoomPermission, b as FrameConsentAnswer, c as AdoptRequest, d as ConflictRequest, et as RoomJoinOptions, it as RoomOpenOptions, jt as TcpSocketListenerOptions, l as AdoptState, m as ConnectOptions, o as AccountPinOptions, p as ConnectAvailability, st as RoomsErrorCode, tt as RoomMailbox, u as ConflictChoice, x as FrameConsentRequest, xt as StorageErrorCode, z as Placement } from "./contract-BN0cD-Oq.js";
+import { $ as RoomEvent, Bt as UdpSocketOptions, D as IpFamily, Ft as TcpSocketListenerOptions, H as ProxyFetchInput, I as PackagesErrorCode, J as RoomClaimOptions, K as Resolvers, Kt as WriteData, Lt as TcpSocketOptions, N as OverlayState, P as PackageQuery, R as PickOptions, T as InstallOptions, Tt as StorageErrorCode, V as ProxyFetchInit, a as AccountChange, b as FrameConsentAnswer, c as AdoptRequest, d as ConflictRequest, dt as RoomsErrorCode, kt as StoragePutWire, l as AdoptState, m as ConnectOptions, o as AccountPinOptions, ot as RoomOpenOptions, p as ConnectAvailability, rt as RoomMailbox, st as RoomPermission, tt as RoomJoinOptions, u as ConflictChoice, ut as RoomType, x as FrameConsentRequest, z as Placement, zt as UdpDatagram } from "./contract-DFycgFJK.js";
 import { o as TcpSocketOption, x as UdpSocketOption } from "./wire-Fk5pJaoy.js";
 import { Remote } from "osra";
 //#region src/api-epochs.d.ts
@@ -313,6 +313,7 @@ declare const onApiEpoch: (listener: EpochListener<{
       mailbox: RoomMailbox | null;
       temporaryClaims?: true;
       mailboxSwitch?: true;
+      schemas?: true;
       defaults: () => Promise<{
         readonly send: boolean;
         readonly receive: boolean;
@@ -328,13 +329,40 @@ declare const onApiEpoch: (listener: EpochListener<{
         };
         maxMessageBytes: number;
       }[]>;
-      send: (text: string) => Promise<{
+      schema: () => Promise<{
+        readonly version: number;
+        readonly types: {
+          readonly [x: string]: {
+            readonly envelope: {
+              readonly [x: string]: unknown;
+            };
+            readonly send?: 'owner' | 'accounts' | 'members';
+            readonly maxBytes?: number;
+            readonly perAccount?: {
+              readonly messages?: number;
+              readonly bytes?: number;
+            } | undefined;
+          };
+        };
+        readonly maxStoredBytes?: number;
+      } | null>;
+      send: (text: string, envelope?: string | undefined) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
         ok: true;
       }>;
-      edit: (seq: number, text: string) => Promise<{
+      edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+        error: RoomsErrorCode;
+        message: string;
+      } | {
+        ok: true;
+      }>;
+      setSchema: (schema: Readonly<{
+        version: number;
+        types: Readonly<Record<string, RoomType>>;
+        maxStoredBytes?: number;
+      }>) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
@@ -451,6 +479,7 @@ declare const onApiEpoch: (listener: EpochListener<{
       mailbox: RoomMailbox | null;
       temporaryClaims?: true;
       mailboxSwitch?: true;
+      schemas?: true;
       defaults: () => Promise<{
         readonly send: boolean;
         readonly receive: boolean;
@@ -466,13 +495,40 @@ declare const onApiEpoch: (listener: EpochListener<{
         };
         maxMessageBytes: number;
       }[]>;
-      send: (text: string) => Promise<{
+      schema: () => Promise<{
+        readonly version: number;
+        readonly types: {
+          readonly [x: string]: {
+            readonly envelope: {
+              readonly [x: string]: unknown;
+            };
+            readonly send?: 'owner' | 'accounts' | 'members';
+            readonly maxBytes?: number;
+            readonly perAccount?: {
+              readonly messages?: number;
+              readonly bytes?: number;
+            } | undefined;
+          };
+        };
+        readonly maxStoredBytes?: number;
+      } | null>;
+      send: (text: string, envelope?: string | undefined) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
         ok: true;
       }>;
-      edit: (seq: number, text: string) => Promise<{
+      edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+        error: RoomsErrorCode;
+        message: string;
+      } | {
+        ok: true;
+      }>;
+      setSchema: (schema: Readonly<{
+        version: number;
+        types: Readonly<Record<string, RoomType>>;
+        maxStoredBytes?: number;
+      }>) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
@@ -589,6 +645,7 @@ declare const onApiEpoch: (listener: EpochListener<{
       mailbox: RoomMailbox | null;
       temporaryClaims?: true;
       mailboxSwitch?: true;
+      schemas?: true;
       defaults: () => Promise<{
         readonly send: boolean;
         readonly receive: boolean;
@@ -604,13 +661,40 @@ declare const onApiEpoch: (listener: EpochListener<{
         };
         maxMessageBytes: number;
       }[]>;
-      send: (text: string) => Promise<{
+      schema: () => Promise<{
+        readonly version: number;
+        readonly types: {
+          readonly [x: string]: {
+            readonly envelope: {
+              readonly [x: string]: unknown;
+            };
+            readonly send?: 'owner' | 'accounts' | 'members';
+            readonly maxBytes?: number;
+            readonly perAccount?: {
+              readonly messages?: number;
+              readonly bytes?: number;
+            } | undefined;
+          };
+        };
+        readonly maxStoredBytes?: number;
+      } | null>;
+      send: (text: string, envelope?: string | undefined) => Promise<{
+        error: RoomsErrorCode;
+        message: string;
+      } | {
+        ok: true;
+      }>;
+      edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
         ok: true;
       }>;
-      edit: (seq: number, text: string) => Promise<{
+      setSchema: (schema: Readonly<{
+        version: number;
+        types: Readonly<Record<string, RoomType>>;
+        maxStoredBytes?: number;
+      }>) => Promise<{
         error: RoomsErrorCode;
         message: string;
       } | {
@@ -687,26 +771,526 @@ declare const onApiEpoch: (listener: EpochListener<{
         error: RoomsErrorCode;
         message: string;
       } | {
-        ok: true;
-      }>;
-      usage: () => Promise<{
+        ok: true;
+      }>;
+      usage: () => Promise<{
+        error: RoomsErrorCode;
+        message: string;
+      } | {
+        messages: number;
+        bytes: number;
+        cap: number;
+        archived: boolean;
+      } | null>;
+      on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+      leave: () => Promise<void>;
+      closed: Promise<{
+        reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+      }>;
+    } | {
+      error: RoomsErrorCode;
+      message: string;
+    }>;
+    guest: {
+      open: (name: string, options?: RoomOpenOptions | undefined) => Promise<{
+        id: string;
+        name: string;
+        key: string;
+        invite: string;
+        self: {
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        };
+        owner: string;
+        claimed: boolean;
+        mailbox: RoomMailbox | null;
+        temporaryClaims?: true;
+        mailboxSwitch?: true;
+        schemas?: true;
+        defaults: () => Promise<{
+          readonly send: boolean;
+          readonly receive: boolean;
+          readonly maxMessageBytes: number;
+        }>;
+        members: () => Promise<{
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        }[]>;
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        delete: (from: number, to?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        backlog: (after: number, limit?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          last: number;
+          more: boolean;
+        }>;
+        setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        grant: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        revoke: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        remove: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        block: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        unblock: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        claim: (options?: RoomClaimOptions | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setMailbox: (on: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        release: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        usage: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          messages: number;
+          bytes: number;
+          cap: number;
+          archived: boolean;
+        } | null>;
+        on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+        leave: () => Promise<void>;
+        closed: Promise<{
+          reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+        }>;
+      } | {
+        error: RoomsErrorCode;
+        message: string;
+      }>;
+      create: (options?: RoomOpenOptions | undefined) => Promise<{
+        id: string;
+        name: string;
+        key: string;
+        invite: string;
+        self: {
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        };
+        owner: string;
+        claimed: boolean;
+        mailbox: RoomMailbox | null;
+        temporaryClaims?: true;
+        mailboxSwitch?: true;
+        schemas?: true;
+        defaults: () => Promise<{
+          readonly send: boolean;
+          readonly receive: boolean;
+          readonly maxMessageBytes: number;
+        }>;
+        members: () => Promise<{
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        }[]>;
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        delete: (from: number, to?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        backlog: (after: number, limit?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          last: number;
+          more: boolean;
+        }>;
+        setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        grant: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        revoke: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        remove: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        block: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        unblock: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        claim: (options?: RoomClaimOptions | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setMailbox: (on: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        release: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        usage: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          messages: number;
+          bytes: number;
+          cap: number;
+          archived: boolean;
+        } | null>;
+        on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+        leave: () => Promise<void>;
+        closed: Promise<{
+          reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+        }>;
+      } | {
+        error: RoomsErrorCode;
+        message: string;
+      }>;
+      join: (invite: string, options?: RoomJoinOptions | undefined) => Promise<{
+        id: string;
+        name: string;
+        key: string;
+        invite: string;
+        self: {
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        };
+        owner: string;
+        claimed: boolean;
+        mailbox: RoomMailbox | null;
+        temporaryClaims?: true;
+        mailboxSwitch?: true;
+        schemas?: true;
+        defaults: () => Promise<{
+          readonly send: boolean;
+          readonly receive: boolean;
+          readonly maxMessageBytes: number;
+        }>;
+        members: () => Promise<{
+          id: string;
+          permissions: {
+            readonly block: boolean;
+            readonly receive: boolean;
+            readonly remove: boolean;
+            readonly send: boolean;
+          };
+          maxMessageBytes: number;
+        }[]>;
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        delete: (from: number, to?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        backlog: (after: number, limit?: number | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          last: number;
+          more: boolean;
+        }>;
+        setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        grant: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        revoke: (id: string, permission: RoomPermission) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        remove: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        block: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        unblock: (id: string) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        claim: (options?: RoomClaimOptions | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        setMailbox: (on: boolean) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        release: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        usage: () => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          messages: number;
+          bytes: number;
+          cap: number;
+          archived: boolean;
+        } | null>;
+        on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+        leave: () => Promise<void>;
+        closed: Promise<{
+          reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+        }>;
+      } | {
         error: RoomsErrorCode;
         message: string;
-      } | {
-        messages: number;
-        bytes: number;
-        cap: number;
-        archived: boolean;
-      } | null>;
-      on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
-      leave: () => Promise<void>;
-      closed: Promise<{
-        reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
       }>;
-    } | {
-      error: RoomsErrorCode;
-      message: string;
-    }>;
+    };
   };
   storage: {
     available: () => Promise<boolean>;
@@ -1100,6 +1684,7 @@ declare const currentApiEpoch: () => {
         mailbox: RoomMailbox | null;
         temporaryClaims?: true;
         mailboxSwitch?: true;
+        schemas?: true;
         defaults: () => Promise<{
           readonly send: boolean;
           readonly receive: boolean;
@@ -1115,13 +1700,40 @@ declare const currentApiEpoch: () => {
           };
           maxMessageBytes: number;
         }[]>;
-        send: (text: string) => Promise<{
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
           ok: true;
         }>;
-        edit: (seq: number, text: string) => Promise<{
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
@@ -1238,6 +1850,7 @@ declare const currentApiEpoch: () => {
         mailbox: RoomMailbox | null;
         temporaryClaims?: true;
         mailboxSwitch?: true;
+        schemas?: true;
         defaults: () => Promise<{
           readonly send: boolean;
           readonly receive: boolean;
@@ -1253,13 +1866,40 @@ declare const currentApiEpoch: () => {
           };
           maxMessageBytes: number;
         }[]>;
-        send: (text: string) => Promise<{
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
           ok: true;
         }>;
-        edit: (seq: number, text: string) => Promise<{
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
@@ -1376,6 +2016,7 @@ declare const currentApiEpoch: () => {
         mailbox: RoomMailbox | null;
         temporaryClaims?: true;
         mailboxSwitch?: true;
+        schemas?: true;
         defaults: () => Promise<{
           readonly send: boolean;
           readonly receive: boolean;
@@ -1391,13 +2032,40 @@ declare const currentApiEpoch: () => {
           };
           maxMessageBytes: number;
         }[]>;
-        send: (text: string) => Promise<{
+        schema: () => Promise<{
+          readonly version: number;
+          readonly types: {
+            readonly [x: string]: {
+              readonly envelope: {
+                readonly [x: string]: unknown;
+              };
+              readonly send?: 'owner' | 'accounts' | 'members';
+              readonly maxBytes?: number;
+              readonly perAccount?: {
+                readonly messages?: number;
+                readonly bytes?: number;
+              } | undefined;
+            };
+          };
+          readonly maxStoredBytes?: number;
+        } | null>;
+        send: (text: string, envelope?: string | undefined) => Promise<{
+          error: RoomsErrorCode;
+          message: string;
+        } | {
+          ok: true;
+        }>;
+        edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
           ok: true;
         }>;
-        edit: (seq: number, text: string) => Promise<{
+        setSchema: (schema: Readonly<{
+          version: number;
+          types: Readonly<Record<string, RoomType>>;
+          maxStoredBytes?: number;
+        }>) => Promise<{
           error: RoomsErrorCode;
           message: string;
         } | {
@@ -1494,6 +2162,506 @@ declare const currentApiEpoch: () => {
         error: RoomsErrorCode;
         message: string;
       }>;
+      guest: {
+        open: (name: string, options?: RoomOpenOptions | undefined) => Promise<{
+          id: string;
+          name: string;
+          key: string;
+          invite: string;
+          self: {
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          };
+          owner: string;
+          claimed: boolean;
+          mailbox: RoomMailbox | null;
+          temporaryClaims?: true;
+          mailboxSwitch?: true;
+          schemas?: true;
+          defaults: () => Promise<{
+            readonly send: boolean;
+            readonly receive: boolean;
+            readonly maxMessageBytes: number;
+          }>;
+          members: () => Promise<{
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          }[]>;
+          schema: () => Promise<{
+            readonly version: number;
+            readonly types: {
+              readonly [x: string]: {
+                readonly envelope: {
+                  readonly [x: string]: unknown;
+                };
+                readonly send?: 'owner' | 'accounts' | 'members';
+                readonly maxBytes?: number;
+                readonly perAccount?: {
+                  readonly messages?: number;
+                  readonly bytes?: number;
+                } | undefined;
+              };
+            };
+            readonly maxStoredBytes?: number;
+          } | null>;
+          send: (text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setSchema: (schema: Readonly<{
+            version: number;
+            types: Readonly<Record<string, RoomType>>;
+            maxStoredBytes?: number;
+          }>) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          delete: (from: number, to?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          backlog: (after: number, limit?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            last: number;
+            more: boolean;
+          }>;
+          setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          grant: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          revoke: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          remove: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          block: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          unblock: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          claim: (options?: RoomClaimOptions | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setMailbox: (on: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          release: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          usage: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            messages: number;
+            bytes: number;
+            cap: number;
+            archived: boolean;
+          } | null>;
+          on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+          leave: () => Promise<void>;
+          closed: Promise<{
+            reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+          }>;
+        } | {
+          error: RoomsErrorCode;
+          message: string;
+        }>;
+        create: (options?: RoomOpenOptions | undefined) => Promise<{
+          id: string;
+          name: string;
+          key: string;
+          invite: string;
+          self: {
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          };
+          owner: string;
+          claimed: boolean;
+          mailbox: RoomMailbox | null;
+          temporaryClaims?: true;
+          mailboxSwitch?: true;
+          schemas?: true;
+          defaults: () => Promise<{
+            readonly send: boolean;
+            readonly receive: boolean;
+            readonly maxMessageBytes: number;
+          }>;
+          members: () => Promise<{
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          }[]>;
+          schema: () => Promise<{
+            readonly version: number;
+            readonly types: {
+              readonly [x: string]: {
+                readonly envelope: {
+                  readonly [x: string]: unknown;
+                };
+                readonly send?: 'owner' | 'accounts' | 'members';
+                readonly maxBytes?: number;
+                readonly perAccount?: {
+                  readonly messages?: number;
+                  readonly bytes?: number;
+                } | undefined;
+              };
+            };
+            readonly maxStoredBytes?: number;
+          } | null>;
+          send: (text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setSchema: (schema: Readonly<{
+            version: number;
+            types: Readonly<Record<string, RoomType>>;
+            maxStoredBytes?: number;
+          }>) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          delete: (from: number, to?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          backlog: (after: number, limit?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            last: number;
+            more: boolean;
+          }>;
+          setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          grant: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          revoke: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          remove: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          block: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          unblock: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          claim: (options?: RoomClaimOptions | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setMailbox: (on: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          release: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          usage: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            messages: number;
+            bytes: number;
+            cap: number;
+            archived: boolean;
+          } | null>;
+          on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+          leave: () => Promise<void>;
+          closed: Promise<{
+            reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+          }>;
+        } | {
+          error: RoomsErrorCode;
+          message: string;
+        }>;
+        join: (invite: string, options?: RoomJoinOptions | undefined) => Promise<{
+          id: string;
+          name: string;
+          key: string;
+          invite: string;
+          self: {
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          };
+          owner: string;
+          claimed: boolean;
+          mailbox: RoomMailbox | null;
+          temporaryClaims?: true;
+          mailboxSwitch?: true;
+          schemas?: true;
+          defaults: () => Promise<{
+            readonly send: boolean;
+            readonly receive: boolean;
+            readonly maxMessageBytes: number;
+          }>;
+          members: () => Promise<{
+            id: string;
+            permissions: {
+              readonly block: boolean;
+              readonly receive: boolean;
+              readonly remove: boolean;
+              readonly send: boolean;
+            };
+            maxMessageBytes: number;
+          }[]>;
+          schema: () => Promise<{
+            readonly version: number;
+            readonly types: {
+              readonly [x: string]: {
+                readonly envelope: {
+                  readonly [x: string]: unknown;
+                };
+                readonly send?: 'owner' | 'accounts' | 'members';
+                readonly maxBytes?: number;
+                readonly perAccount?: {
+                  readonly messages?: number;
+                  readonly bytes?: number;
+                } | undefined;
+              };
+            };
+            readonly maxStoredBytes?: number;
+          } | null>;
+          send: (text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          edit: (seq: number, text: string, envelope?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setSchema: (schema: Readonly<{
+            version: number;
+            types: Readonly<Record<string, RoomType>>;
+            maxStoredBytes?: number;
+          }>) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          delete: (from: number, to?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          backlog: (after: number, limit?: number | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            last: number;
+            more: boolean;
+          }>;
+          setDefault: (permission: "receive" | "send", value: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          limit: (maxMessageBytes: number | null, id?: string | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          grant: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          revoke: (id: string, permission: RoomPermission) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          remove: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          block: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          unblock: (id: string) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          claim: (options?: RoomClaimOptions | undefined) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          setMailbox: (on: boolean) => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          release: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            ok: true;
+          }>;
+          usage: () => Promise<{
+            error: RoomsErrorCode;
+            message: string;
+          } | {
+            messages: number;
+            bytes: number;
+            cap: number;
+            archived: boolean;
+          } | null>;
+          on: (listener: (event: RoomEvent) => void) => Promise<() => Promise<void>>;
+          leave: () => Promise<void>;
+          closed: Promise<{
+            reason: 'left' | 'removed' | 'blocked' | 'ended' | 'unavailable';
+          }>;
+        } | {
+          error: RoomsErrorCode;
+          message: string;
+        }>;
+      };
     };
     storage: {
       available: () => Promise<boolean>;