@flow-industries/id 0.22.0 → 0.22.1

package/dist/sdk/client/dialog-host.js

@@ -1,4 +1,4 @@
-import { bridgeToWindow, makeIframe } from "./iframe-host";
+import { bridgeToWindow, makeIframe, sendBridgeNotification, } from "./iframe-host";
 import { setOverlayFocus } from "./overlay-focus";
 const HIDDEN_STYLE = {
     position: "fixed",
@@ -106,7 +106,7 @@ export function createDialogHost(options) {
             return;
         initSent = true;
         // SAFETY: the payload map types this topic; the dialog reads exactly these fields.
-        messenger?.send("__internal", {
+        sendBridgeNotification(messenger, "__internal", {
             type: "init",
             mode: "iframe",
             referrer: opts?.referrer ?? { title: document.title },
@@ -124,7 +124,7 @@ export function createDialogHost(options) {
         // widget, so every dialog appears and disappears identically.
         void (
         // SAFETY: the payload map types this topic; the dialog reads exactly these fields.
-        messenger?.send("__internal", { type: "dialog-shown" }));
+        sendBridgeNotification(messenger, "__internal", { type: "dialog-shown" }));
     }
     function hide() {
         if (!iframe)
@@ -137,7 +137,7 @@ export function createDialogHost(options) {
         setOverlayFocus(iframe, false);
         void (
         // SAFETY: the payload map types this topic; the dialog reads exactly these fields.
-        messenger?.send("__internal", { type: "dialog-hidden" }));
+        sendBridgeNotification(messenger, "__internal", { type: "dialog-hidden" }));
     }
     function open(opts) {
         if (opts?.mode === "popup") {
@@ -177,9 +177,14 @@ export function createDialogHost(options) {
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
             // SAFETY: the rpc-requests payload shape.
-            messenger.send("rpc-requests", [
+            messenger
+                .send("rpc-requests", [
                 { request: rpcRequest, status: "pending" },
-            ]);
+            ])
+                .catch((error) => {
+                pending.delete(id);
+                reject(error);
+            });
         });
     }
     /** Opens the dialog UI and dispatches an interactive RPC (login, sign, etc.). */

package/dist/sdk/client/flow-widget.js

@@ -1,6 +1,6 @@
 import { resolveIdHost } from "../id-host";
 import { getFlow, requireFlow } from "./create-flow";
-import { answerTokenRequest, bridgeToWindow, makeIframe } from "./iframe-host";
+import { answerTokenRequest, bridgeToWindow, makeIframe, sendBridgeNotification, } from "./iframe-host";
 /**
  * The inline widgets an embedder may mount, mapped to the dialog routes that
  * serve them. Callers name a widget rather than passing a route so the dialog's
@@ -65,7 +65,7 @@ export function createFlowWidget(options) {
     // confirms where the frame is; what the handshake is really for is telling
     // the dialog which origin it is embedded by, which is what it later asks for
     // a token.
-    void bridge.send("__internal", {
+    sendBridgeNotification(bridge, "__internal", {
         type: "init",
         mode: "iframe",
         referrer: { title: document.title },
@@ -81,7 +81,7 @@ export function createFlowWidget(options) {
             if (next === theme)
                 return;
             theme = next;
-            void bridge.send("__internal", {
+            sendBridgeNotification(bridge, "__internal", {
                 type: "set-theme",
                 theme: { colorScheme: next },
             });

package/dist/sdk/client/iframe-host.d.ts

@@ -1,5 +1,5 @@
 import * as Messenger from "../dialog/remote/Messenger";
-import type { Flow, ProfileIdentity } from "../types";
+import type { Flow, Payload, ProfileIdentity, Topic } from "../types";
 /**
  * Permissions the dialog iframe needs to run WebAuthn passkey ceremonies and
  * copy recovery values. Shared by every Flow iframe host (the dialog host and
@@ -48,3 +48,4 @@ export declare function hostIdentity(flow: Flow): ProfileIdentity | null;
  * out — instead of leaving the request to time out.
  */
 export declare function answerTokenRequest(bridge: Messenger.Bridge, flow: Flow, id: string): Promise<void>;
+export declare function sendBridgeNotification<T extends Topic>(bridge: Messenger.Bridge | null | undefined, topic: T, payload: Payload<T>): void;

package/dist/sdk/client/iframe-host.js

@@ -71,5 +71,15 @@ export function hostIdentity(flow) {
  */
 export async function answerTokenRequest(bridge, flow, id) {
     const token = await flow.getToken().catch(() => null);
-    void bridge.send("__internal", { type: "profile-token", id, token });
+    sendBridgeNotification(bridge, "__internal", {
+        type: "profile-token",
+        id,
+        token,
+    });
+}
+export function sendBridgeNotification(bridge, topic, payload) {
+    void bridge?.send(topic, payload).catch((error) => {
+        if (!(error instanceof Messenger.BridgeDestroyedError))
+            throw error;
+    });
 }

package/dist/sdk/client/index.d.ts

@@ -9,6 +9,8 @@ export { actionHeadline, anchorFor, catalogFieldIndex, createFocusApi, elapsedSe
 export { METHODS } from "./methods";
 export { closeProfile, openProfile } from "./open-profile";
 export { createProfileButton } from "./profile-button";
+export type { ReportOperation, ReportRequest, ReportResponse } from "./reports";
+export { createReportsApi, ReportRequestError } from "./reports";
 export { createRoomsApi, RoomsRequestError } from "./rooms";
 export { createStaticFlow } from "./static-flow";
 export { createStudyApi, StudyRequestError } from "./study";

package/dist/sdk/client/index.js

@@ -8,6 +8,7 @@ export { actionHeadline, anchorFor, catalogFieldIndex, createFocusApi, elapsedSe
 export { METHODS } from "./methods";
 export { closeProfile, openProfile } from "./open-profile";
 export { createProfileButton } from "./profile-button";
+export { createReportsApi, ReportRequestError } from "./reports";
 export { createRoomsApi, RoomsRequestError } from "./rooms";
 export { createStaticFlow } from "./static-flow";
 export { createStudyApi, StudyRequestError } from "./study";

package/dist/sdk/client/open-profile.js

@@ -1,7 +1,7 @@
 import { resolveIdHost } from "../id-host";
 import { isValidUsername } from "../usernames";
 import { getFlow, requireFlow } from "./create-flow";
-import { answerTokenRequest, bridgeToWindow, hostIdentity, makeIframe, OVERLAY_STYLE, } from "./iframe-host";
+import { answerTokenRequest, bridgeToWindow, hostIdentity, makeIframe, OVERLAY_STYLE, sendBridgeNotification, } from "./iframe-host";
 import { setOverlayFocus } from "./overlay-focus";
 // One overlay per page, kept for the page's lifetime. The alternative — a
 // handle per call site — would put a second fullscreen iframe over the host the
@@ -47,7 +47,7 @@ function createViewer(options) {
         // `/dialog/` and `init` asks it to land on the profile. Sending the route
         // here rather than as a follow-up message keeps the sign-in root from ever
         // mounting, even for the frame it takes to navigate away from it.
-        void opened.send("__internal", {
+        sendBridgeNotification(opened, "__internal", {
             type: "init",
             mode: "iframe",
             referrer: { title: document.title },
@@ -90,11 +90,14 @@ function createViewer(options) {
         // re-pointed in place. Tearing it down and rebuilding would reload the
         // dialog and lose the open animation on every profile after the first.
         if (mounted)
-            void live.send("__internal", { type: "profile-view", username });
+            sendBridgeNotification(live, "__internal", {
+                type: "profile-view",
+                username,
+            });
         // Pushed on every open rather than tracked with a subscription: it is only
         // read while a profile is on screen, and sending it here means the "this is
         // you" link is decided from the session as it stands at that moment.
-        void live.send("__internal", {
+        sendBridgeNotification(live, "__internal", {
             type: "profile-identity",
             identity: hostIdentity(flow),
         });
@@ -102,7 +105,7 @@ function createViewer(options) {
         onClose = nextOnClose;
         visible = true;
         applyHitTesting();
-        void live.send("__internal", { type: "dialog-shown" });
+        sendBridgeNotification(live, "__internal", { type: "dialog-shown" });
     }
     // Visibility is hit-testing plus a message, and nothing else. The overlay
     // iframe is NEVER set to `display: none` — that pauses the iframe's
@@ -116,7 +119,7 @@ function createViewer(options) {
         visible = false;
         window.removeEventListener("keydown", onKeyDown);
         applyHitTesting();
-        void bridge.send("__internal", { type: "dialog-hidden" });
+        sendBridgeNotification(bridge, "__internal", { type: "dialog-hidden" });
         const notifyClose = onClose;
         onClose = undefined;
         notifyClose?.();
@@ -131,7 +134,7 @@ function createViewer(options) {
         if (next === theme)
             return;
         theme = next;
-        void bridge?.send("__internal", {
+        sendBridgeNotification(bridge, "__internal", {
             type: "set-theme",
             theme: { colorScheme: next },
         });

package/dist/sdk/client/profile-button.js

@@ -1,6 +1,6 @@
 import { resolveIdHost } from "../id-host";
 import { getFlow, requireFlow } from "./create-flow";
-import { answerTokenRequest, bridgeToWindow, hostIdentity, makeIframe, OVERLAY_STYLE, } from "./iframe-host";
+import { answerTokenRequest, bridgeToWindow, hostIdentity, makeIframe, OVERLAY_STYLE, sendBridgeNotification, } from "./iframe-host";
 import { setOverlayFocus } from "./overlay-focus";
 const POSITION_STYLE = {
     "top-right": { top: "0", right: "0" },
@@ -62,7 +62,7 @@ export function createProfileButton(options) {
         const bridge = bridgeToWindow(frame.contentWindow, {
             targetOrigin: hostOrigin,
         });
-        bridge.send("__internal", {
+        sendBridgeNotification(bridge, "__internal", {
             type: "init",
             mode: "iframe",
             referrer: { title: document.title },
@@ -130,7 +130,7 @@ export function createProfileButton(options) {
                     void answerTokenRequest(dialogBridge, flow, payload.id);
             }
         });
-        void dialogBridge.send("__internal", {
+        sendBridgeNotification(dialogBridge, "__internal", {
             type: "profile-identity",
             identity: hostIdentity(flow),
         });
@@ -147,14 +147,18 @@ export function createProfileButton(options) {
             return;
         dialog.style.pointerEvents = "auto";
         setOverlayFocus(dialog, true);
-        void dialogBridge?.send("__internal", { type: "dialog-shown" });
+        sendBridgeNotification(dialogBridge, "__internal", {
+            type: "dialog-shown",
+        });
     }
     function hideDialog() {
         if (!dialog)
             return;
         dialog.style.pointerEvents = "none";
         setOverlayFocus(dialog, false);
-        void dialogBridge?.send("__internal", { type: "dialog-hidden" });
+        sendBridgeNotification(dialogBridge, "__internal", {
+            type: "dialog-hidden",
+        });
     }
     // ----- keep both iframes' identity in sync with the Flow session -----
     // flow.subscribe fires on any store change (jwt/credential/address too), so
@@ -166,9 +170,12 @@ export function createProfileButton(options) {
         if (key === lastIdentityKey)
             return;
         lastIdentityKey = key;
-        void pillBridge.send("__internal", { type: "profile-identity", identity });
+        sendBridgeNotification(pillBridge, "__internal", {
+            type: "profile-identity",
+            identity,
+        });
         if (dialogBridge)
-            void dialogBridge.send("__internal", {
+            sendBridgeNotification(dialogBridge, "__internal", {
                 type: "profile-identity",
                 identity,
             });
@@ -180,11 +187,11 @@ export function createProfileButton(options) {
             if (next === theme)
                 return;
             theme = next;
-            void pillBridge.send("__internal", {
+            sendBridgeNotification(pillBridge, "__internal", {
                 type: "set-theme",
                 theme: { colorScheme: next },
             });
-            void dialogBridge?.send("__internal", {
+            sendBridgeNotification(dialogBridge, "__internal", {
                 type: "set-theme",
                 theme: { colorScheme: next },
             });

package/dist/sdk/client/reports.d.ts

@@ -0,0 +1,9 @@
+import type { ReportsApi, ReportTransport } from "../types/reports";
+export type { ReportOperation, ReportRequest, ReportResponse, } from "../types/reports";
+export declare class ReportRequestError extends Error {
+    readonly status: number;
+    readonly response: string;
+    constructor(status: number, response: string);
+}
+/** Typed service reports. Keep the reporting bearer on trusted servers only. */
+export declare function createReportsApi(host: string, token: string, transport?: ReportTransport): ReportsApi;

package/dist/sdk/client/reports.js

@@ -0,0 +1,30 @@
+import { httpOperations } from "../contracts/http";
+export class ReportRequestError extends Error {
+    status;
+    response;
+    constructor(status, response) {
+        super(`Flow report failed (${status})`);
+        this.status = status;
+        this.response = response;
+        this.name = "ReportRequestError";
+    }
+}
+/** Typed service reports. Keep the reporting bearer on trusted servers only. */
+export function createReportsApi(host, token, transport = fetch) {
+    return async function report(operation, body) {
+        const contract = httpOperations[operation];
+        const request = contract.request.parse(body);
+        const response = await transport(new URL(contract.path, host), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok)
+            throw new ReportRequestError(response.status, await response.text());
+        // SAFETY: the selected operation owns both this response schema and the mapped response type.
+        return contract.response.parse(await response.json());
+    };
+}

package/dist/sdk/contracts/http.d.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+export declare const httpOperations: {
+    readonly startAction: {
+        readonly path: "/api/actions/start";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            sessionId: z.ZodString;
+            source: z.ZodString;
+            showTimer: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly eventAction: {
+        readonly path: "/api/actions/event";
+        readonly request: z.ZodObject<{
+            sessionId: z.ZodString;
+            kind: z.ZodEnum<{
+                pause: "pause";
+                resume: "resume";
+                focus_lost: "focus_lost";
+                focus_gained: "focus_gained";
+            }>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            recorded: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly finishAction: {
+        readonly path: "/api/actions/finish";
+        readonly request: z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            xpGranted: z.ZodNullable<z.ZodObject<{
+                granted: z.ZodBoolean;
+                amount: z.ZodNumber;
+                totalXp: z.ZodNumber;
+                flowScore: z.ZodNumber;
+                level: z.ZodNumber;
+                tier: z.ZodNumber;
+                xpIntoLevel: z.ZodNumber;
+                xpForNextLevel: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly reportStateTime: {
+        readonly path: "/api/actions/state-time";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            day: z.ZodString;
+            states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly reportXp: {
+        readonly path: "/api/xp/events";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            source: z.ZodString;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            granted: z.ZodBoolean;
+            amount: z.ZodNumber;
+            totalXp: z.ZodNumber;
+            flowScore: z.ZodNumber;
+            level: z.ZodNumber;
+            tier: z.ZodNumber;
+            xpIntoLevel: z.ZodNumber;
+            xpForNextLevel: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly reportPresence: {
+        readonly path: "/api/rooms/presence/report";
+        readonly request: z.ZodObject<{
+            channel: z.ZodEnum<{
+                game: "game";
+                voice: "voice";
+                text: "text";
+            }>;
+            rooms: z.ZodArray<z.ZodObject<{
+                roomId: z.ZodString;
+                occupants: z.ZodArray<z.ZodObject<{
+                    sub: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly reportPosition: {
+        readonly path: "/api/rooms/position/report";
+        readonly request: z.ZodObject<{
+            positions: z.ZodArray<z.ZodObject<{
+                roomId: z.ZodString;
+                sub: z.ZodString;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+                yaw: z.ZodNumber;
+                worldId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            stored: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+};
+export declare const jwtClaimsSchema: z.ZodObject<{
+    sub: z.ZodString;
+    aud: z.ZodString;
+    iss: z.ZodString;
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+    guest: z.ZodBoolean;
+    username: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const sessionResponseSchema: z.ZodObject<{
+    jwt: z.ZodString;
+    refreshToken: z.ZodString;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodString;
+        isGuest: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    credential: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        publicKey: z.ZodString;
+    }, z.core.$strip>>;
+    additionalSessions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        audience: z.ZodString;
+        jwt: z.ZodString;
+        refreshToken: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$loose>;
+export declare const jwksSchema: z.ZodObject<{
+    keys: z.ZodArray<z.ZodObject<{
+        kid: z.ZodString;
+        kty: z.ZodLiteral<"OKP">;
+        crv: z.ZodLiteral<"Ed25519">;
+        x: z.ZodString;
+        alg: z.ZodOptional<z.ZodLiteral<"EdDSA">>;
+        use: z.ZodOptional<z.ZodLiteral<"sig">>;
+        d: z.ZodOptional<z.ZodNever>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/sdk/contracts/http.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { actionEventSchema, actionFinishSchema, actionStartSchema, positionReportSchema, presenceReportSchema, stateTimeSchema, xpEventSchema, } from "./reports";
+const okResponseSchema = z.object({ ok: z.literal(true) });
+const xpGrantResponseSchema = z.object({
+    granted: z.boolean(),
+    amount: z.number(),
+    totalXp: z.number(),
+    flowScore: z.number(),
+    level: z.number(),
+    tier: z.number(),
+    xpIntoLevel: z.number(),
+    xpForNextLevel: z.number(),
+});
+export const httpOperations = {
+    startAction: {
+        path: "/api/actions/start",
+        request: actionStartSchema,
+        response: okResponseSchema,
+    },
+    eventAction: {
+        path: "/api/actions/event",
+        request: actionEventSchema,
+        response: okResponseSchema.extend({ recorded: z.boolean() }),
+    },
+    finishAction: {
+        path: "/api/actions/finish",
+        request: actionFinishSchema,
+        response: okResponseSchema.extend({
+            xpGranted: xpGrantResponseSchema.nullable(),
+        }),
+    },
+    reportStateTime: {
+        path: "/api/actions/state-time",
+        request: stateTimeSchema,
+        response: okResponseSchema,
+    },
+    reportXp: {
+        path: "/api/xp/events",
+        request: xpEventSchema,
+        response: xpGrantResponseSchema,
+    },
+    reportPresence: {
+        path: "/api/rooms/presence/report",
+        request: presenceReportSchema,
+        response: okResponseSchema,
+    },
+    reportPosition: {
+        path: "/api/rooms/position/report",
+        request: positionReportSchema,
+        response: okResponseSchema.extend({ stored: z.number() }),
+    },
+};
+export const jwtClaimsSchema = z.looseObject({
+    sub: z.string().min(1),
+    aud: z.string().min(1),
+    iss: z.string().min(1),
+    iat: z.number().int(),
+    exp: z.number().int(),
+    guest: z.boolean(),
+    username: z.string().optional(),
+});
+export const sessionResponseSchema = z.looseObject({
+    jwt: z.string().min(1),
+    refreshToken: z.string().min(1),
+    user: z.looseObject({
+        id: z.string(),
+        username: z.string(),
+        isGuest: z.boolean().optional(),
+    }),
+    credential: z.object({ id: z.string(), publicKey: z.string() }).nullable(),
+    additionalSessions: z
+        .array(z.object({
+        audience: z.string(),
+        jwt: z.string(),
+        refreshToken: z.string(),
+    }))
+        .optional(),
+});
+export const jwksSchema = z.object({
+    keys: z
+        .array(z.object({
+        kid: z.string().min(1),
+        kty: z.literal("OKP"),
+        crv: z.literal("Ed25519"),
+        x: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+        alg: z.literal("EdDSA").optional(),
+        use: z.literal("sig").optional(),
+        d: z.never().optional(),
+    }))
+        .min(1),
+});

package/dist/sdk/contracts/reports.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+/** Game server → auth: a reportable XP event. */
+export declare const xpEventSchema: z.ZodObject<{
+    sub: z.ZodString;
+    source: z.ZodString;
+    durationSeconds: z.ZodOptional<z.ZodNumber>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Talk and the game report a full snapshot of every active room they hold. */
+export declare const presenceReportSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        game: "game";
+        voice: "voice";
+        text: "text";
+    }>;
+    rooms: z.ZodArray<z.ZodObject<{
+        roomId: z.ZodString;
+        occupants: z.ZodArray<z.ZodObject<{
+            sub: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The game server checkpoints each tracked player's last grounded footing. */
+export declare const positionReportSchema: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        roomId: z.ZodString;
+        sub: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+        yaw: z.ZodNumber;
+        worldId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const actionStartSchema: z.ZodObject<{
+    sub: z.ZodString;
+    sessionId: z.ZodString;
+    source: z.ZodString;
+    showTimer: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const actionFinishSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const actionEventSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    kind: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+        focus_lost: "focus_lost";
+        focus_gained: "focus_gained";
+    }>;
+}, z.core.$strip>;
+export declare const stateTimeSchema: z.ZodObject<{
+    sub: z.ZodString;
+    day: z.ZodString;
+    states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const xpDevSchema: z.ZodObject<{
+    sub: z.ZodString;
+    op: z.ZodEnum<{
+        add: "add";
+        set_total: "set_total";
+        set_level: "set_level";
+    }>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export declare const reportSchemas: {
+    xpEvent: z.ZodObject<{
+        sub: z.ZodString;
+        source: z.ZodString;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    presenceReport: z.ZodObject<{
+        channel: z.ZodEnum<{
+            game: "game";
+            voice: "voice";
+            text: "text";
+        }>;
+        rooms: z.ZodArray<z.ZodObject<{
+            roomId: z.ZodString;
+            occupants: z.ZodArray<z.ZodObject<{
+                sub: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    positionReport: z.ZodObject<{
+        positions: z.ZodArray<z.ZodObject<{
+            roomId: z.ZodString;
+            sub: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            yaw: z.ZodNumber;
+            worldId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    actionStart: z.ZodObject<{
+        sub: z.ZodString;
+        sessionId: z.ZodString;
+        source: z.ZodString;
+        showTimer: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    actionEvent: z.ZodObject<{
+        sessionId: z.ZodString;
+        kind: z.ZodEnum<{
+            pause: "pause";
+            resume: "resume";
+            focus_lost: "focus_lost";
+            focus_gained: "focus_gained";
+        }>;
+    }, z.core.$strip>;
+    actionFinish: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>;
+    stateTime: z.ZodObject<{
+        sub: z.ZodString;
+        day: z.ZodString;
+        states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    xpDev: z.ZodObject<{
+        sub: z.ZodString;
+        op: z.ZodEnum<{
+            add: "add";
+            set_total: "set_total";
+            set_level: "set_level";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>;
+};