@etazio/agent-sdk 0.1.0

package/types/shared/dto.d.ts

@@ -0,0 +1,235 @@
+import type { AuthorKind } from './agents.js';
+import type { ChatBlock } from './chat.js';
+import type { WorkspaceRole } from './roles.js';
+export interface UserDto {
+    id: string;
+    email: string;
+    displayName: string;
+    emailVerified: boolean;
+    createdAt: string;
+}
+export interface SessionDto {
+    id: string;
+    createdAt: string;
+    lastSeenAt: string;
+    expiresAt: string;
+    userAgent: string | null;
+    current: boolean;
+}
+export interface WorkspaceDto {
+    id: string;
+    name: string;
+    slug: string;
+    ownerId: string;
+    createdAt: string;
+    /** Rolle des anfragenden Nutzers in diesem Workspace */
+    role: WorkspaceRole;
+    /** Mitglieder dürfen sich freie Schreibtische selbst sichern (SPA-125) */
+    deskSelfClaim: boolean;
+    /**
+     * SPA-94: Die aktuelle Sitzung reicht für diesen Workspace nicht (z. B. „nur SSO“) – dann stehen hier
+     * die zulässigen Anmeldearten, sonst `null`.
+     */
+    loginRequired: Array<'password' | 'magic' | 'google' | 'oidc'> | null;
+}
+/** Workspace-Einstellungen geändert (Socket `workspace:settings`, SPA-125) */
+export interface WorkspaceSettingsPayload {
+    workspaceId: string;
+    deskSelfClaim: boolean;
+}
+export interface MemberDto {
+    userId: string;
+    email: string;
+    displayName: string;
+    role: WorkspaceRole;
+    joinedAt: string;
+}
+export interface InvitationDto {
+    id: string;
+    email: string;
+    role: WorkspaceRole;
+    invitedById: string;
+    createdAt: string;
+    expiresAt: string;
+    acceptedAt: string | null;
+    revokedAt: string | null;
+    /** Letzter Mailversand und wie oft schon gesendet wurde (SPA-99) */
+    lastSentAt: string | null;
+    sentCount: number;
+    /** Abgeleitet: offen, angenommen, zurückgezogen oder abgelaufen */
+    status: 'open' | 'accepted' | 'revoked' | 'expired';
+}
+export interface OfficeRevisionDto {
+    id: string;
+    number: number;
+    schemaVersion: number;
+    /** OfficeLayout aus @huddle/scene-schema (hier untypisiert, damit shared nicht von scene-schema abhängt) */
+    layout: unknown;
+    publishedAt: string;
+}
+export interface DeskAssignmentDto {
+    deskId: string;
+    userId: string;
+    displayName: string;
+    assignedAt: string;
+}
+export interface OfficeDto {
+    id: string;
+    workspaceId: string;
+    name: string;
+    revision: OfficeRevisionDto;
+    /** Arbeitsplatzzuweisungen (Schreibtisch-Instanz → Mitglied) */
+    assignments: DeskAssignmentDto[];
+    /** Persönliche Einrichtung je Schreibtisch (Phase 4) */
+    customizations: DeskCustomizationDto[];
+}
+export interface EditorLockDto {
+    userId: string;
+    displayName: string;
+    /** ISO-Zeitpunkt, bis zu dem die Sperre ohne Verlängerung gilt */
+    expiresAt: string;
+}
+export interface OfficeDraftDto {
+    officeId: string;
+    /** Fortlaufende Versionsnummer des Entwurfs; jede Operation erhöht sie (Basis für Konflikterkennung) */
+    version: number;
+    /** Veröffentlichte Revision, auf der der Entwurf aufsetzt */
+    baseRevisionId: string;
+    baseRevisionNumber: number;
+    /** OfficeLayout aus @huddle/scene-schema */
+    layout: unknown;
+    /** Entwurf weicht von der veröffentlichten Revision ab */
+    dirty: boolean;
+    updatedAt: string;
+    updatedBy: {
+        userId: string;
+        displayName: string;
+    } | null;
+    lock: EditorLockDto | null;
+}
+export interface LayoutIssueDto {
+    code: string;
+    message: string;
+    targetId?: string;
+    otherId?: string;
+}
+export interface RevisionSummaryDto {
+    id: string;
+    number: number;
+    publishedAt: string;
+    createdBy: {
+        userId: string;
+        displayName: string;
+    } | null;
+    note: string | null;
+    /** Aus dieser Revision wiederhergestellt (Rollback) */
+    restoredFrom: number | null;
+    active: boolean;
+    placements: number;
+}
+export interface PublishResultDto {
+    office: OfficeDto;
+    /** Zuweisungen, deren Schreibtisch in der neuen Revision fehlt (wurden entfernt) */
+    removedAssignments: DeskAssignmentDto[];
+    /** Teilnehmer, die auf einen gültigen Punkt versetzt wurden */
+    relocatedParticipants: number;
+    /** Persönliche Gegenstände, die ins Inventar ihrer Besitzer gewandert sind (Schreibtisch/Anker entfernt) */
+    inventoried: number;
+}
+export interface MaterialOverrideDto {
+    color?: string;
+    roughness?: number;
+    metalness?: number;
+}
+/** Persönlicher Gegenstand an einem Schreibtisch-Anker (relativ zum Anker gespeichert, Asset-Vertrag). */
+export interface DeskItemDto {
+    id: string;
+    asset: string;
+    /** Anker-Name ohne Präfix (monitor, lamp, plant, deco) */
+    anchor: string;
+    /** Versatz auf der Ankerebene in Metern [x, z], begrenzt durch DESK_LIMITS.maxOffset; bei `anchor: 'surface'` lokale Position relativ zur Plattenmitte (SPA-95) */
+    offset: [number, number];
+    rotationY: number;
+    overrides?: Record<string, MaterialOverrideDto>;
+}
+export interface DeskCustomizationDto {
+    deskId: string;
+    userId: string;
+    displayName: string;
+    /** Persönliche Namensanzeige am Tisch (null = Anzeigename des Mitglieds) */
+    label: string | null;
+    items: DeskItemDto[];
+    /** Material-Overrides des Schreibtischs (desk_top, desk_frame) */
+    overrides: Record<string, MaterialOverrideDto>;
+    /** Material-Overrides des zugehörigen Stuhls (chair_seat, chair_frame) */
+    chair: Record<string, MaterialOverrideDto>;
+    updatedAt: string;
+}
+export type InventoryReason = 'desk_removed' | 'anchor_removed' | 'reassigned' | 'admin_reset' | 'released';
+/** Gegenstand, der nicht mehr platziert ist (Schreibtisch entfernt, Anker weg, Platz neu vergeben). */
+export interface InventoryItemDto {
+    id: string;
+    asset: string;
+    overrides?: Record<string, MaterialOverrideDto>;
+    fromDeskId: string;
+    reason: InventoryReason;
+    removedAt: string;
+}
+/** Kurzlebiges LiveKit-Token, an Nutzer und Raum gebunden (Roadmap §7). */
+export interface MeetingTokenDto {
+    url: string;
+    token: string;
+    /** LiveKit-Raumname (`<workspaceId>:office` oder `<workspaceId>:zone:<zoneId>`) */
+    room: string;
+    /** 'office' oder Zonen-ID */
+    target: string;
+    expiresAt: string;
+}
+export interface ZoneAccessDto {
+    zoneId: string;
+    /** Dauerhaft freigegebene Mitglieder (Owner/Admin sind immer berechtigt) */
+    userIds: string[];
+}
+export interface ChatReactionDto {
+    glyph: string;
+    userIds: string[];
+}
+export interface ChatMessageDto {
+    id: string;
+    /** Konversation: `room:office`, `room:<zoneId>` oder `dm:<userA>:<userB>` (IDs sortiert) */
+    conv: string;
+    authorId: string;
+    authorName: string;
+    /** Mensch oder KI-Agent (SPA-66); fehlt bei alten Nachrichten und gilt dann als 'user' */
+    authorKind?: AuthorKind;
+    text: string;
+    /** Thread: ID der Wurzelnachricht, null bei Wurzelnachrichten */
+    parentId: string | null;
+    replyCount: number;
+    lastReplyAt: string | null;
+    /** Beteiligte des Threads (an der Wurzel gepflegt) – Avatare in der Zusammenfassung (SPA-117) */
+    replyAuthors?: {
+        userId: string;
+        name: string;
+    }[];
+    /** Thread-Antwort, die zusätzlich im Kanal steht („Auch an den Kanal senden“) */
+    alsoToChannel?: boolean;
+    reactions: ChatReactionDto[];
+    /** Strukturierte Blöcke (Bestätigungs-Karten); fehlt bei allen Bestandsnachrichten */
+    blocks?: ChatBlock[];
+    createdAt: string;
+}
+/** Thread, dem jemand folgt – Grundlage des eigenständigen Ungelesen-Zählers (SPA-117). */
+export interface ChatThreadDto {
+    rootId: string;
+    conv: string;
+    unread: number;
+    lastReplyAt: string | null;
+    lastReadAt: string | null;
+}
+export interface ConversationDto {
+    conv: string;
+    unread: number;
+    lastMessageAt: string | null;
+    lastReadAt: string | null;
+}

package/types/shared/errors.d.ts

@@ -0,0 +1,15 @@
+export declare const ERROR_CODES: readonly ['validation_error', 'unauthenticated', 'forbidden', 'not_found', 'conflict', 
+/** Entwurf ist durch einen anderen Admin gesperrt */
+'locked', 
+/** Layout verletzt Platzierungsregeln (Details: LayoutIssueDto[]) */
+'layout_invalid', 'invitation_expired', 'invitation_used', 'invitation_email_mismatch', 'token_invalid', 'rate_limited', 
+/** Ein nachgelagerter Dienst fehlt oder antwortet nicht (Phase 7f: Renderer) */
+'unavailable', 'internal'];
+export type ErrorCode = (typeof ERROR_CODES)[number];
+export interface ApiErrorBody {
+    error: {
+        code: ErrorCode;
+        message: string;
+        details?: unknown;
+    };
+}

package/types/shared/events.d.ts

@@ -0,0 +1,391 @@
+import type { AgentBadge } from './agents.js';
+import type { AvatarProfile } from './avatar.js';
+import type { ChatMessageDto, ChatReactionDto, DeskCustomizationDto } from './dto.js';
+/** Socket.IO-Ereignisnamen. Client → Server sind Anfragen mit Ack; Server → Client sind Benachrichtigungen. */
+export declare const SOCKET_EVENTS: {
+    readonly workspaceJoin: 'workspace:join';
+    readonly workspaceLeave: 'workspace:leave';
+    readonly worldJoin: 'world:join';
+    readonly worldLeave: 'world:leave';
+    readonly worldMove: 'world:move';
+    readonly worldSit: 'world:sit';
+    readonly worldStand: 'world:stand';
+    /** Winken (Phase 4): Server verteilt world:emote */
+    readonly worldWave: 'world:wave';
+    /** Eigener Medienstatus (Phase 5): Server verteilt world:media */
+    readonly worldMedia: 'world:media';
+    /** An einer privaten Zone klopfen (Phase 5) – Hosts in der Zone bekommen zone:knocked */
+    readonly zoneKnock: 'zone:knock';
+    /** Host lässt einen Klopfenden ein oder lehnt ab (Phase 5) */
+    readonly zoneAdmit: 'zone:admit';
+    /** Reaktion über dem Kopf (Phase 7): Server verteilt world:emote mit Glyph */
+    readonly worldReact: 'world:react';
+    /** Objektzustand setzen (Client → Server mit Ack) und verteilen (Server → Client), Payload: ObjectStatePayload */
+    readonly objectState: 'object:state';
+    /** Einmalige Aktion an einem Objekt (Client → Server mit Ack) und verteilen (Server → Client), Payload: ObjectActionPayload */
+    readonly objectAction: 'object:action';
+    /** Whiteboard-Operation (Client → Server mit Ack {version}) und verteilen (Server → Client), Payload: BoardOpPayload */
+    readonly boardOp: 'board:op';
+    /** Whiteboard laden (Client → Server mit Ack BoardSyncPayload) */
+    readonly boardSync: 'board:sync';
+    /** Zeigerposition auf einem Whiteboard (flüchtig, ohne Ack, beide Richtungen), Payload: BoardCursorPayload */
+    readonly boardCursor: 'board:cursor';
+    /** Web-Anzeige eines TVs abonnieren/abbestellen (Client → Server mit Ack WebStatusPayload), Payload: WebWatchPayload */
+    readonly webWatch: 'web:watch';
+    /** Steuerung übernehmen/abgeben (Client → Server mit Ack WebControlPayload), Payload: { placementId, take } */
+    readonly webControl: 'web:control';
+    /** Eingabe an den Server-Browser (Client → Server, ohne Ack), Payload: { placementId, event } */
+    readonly webInput: 'web:input';
+    /** Navigation im Server-Browser (Client → Server mit Ack), Payload: { placementId, action, url? } */
+    readonly webNavigate: 'web:navigate';
+    /** Sichtfeld des Server-Browsers an die Anzeigegröße des Steuernden angleichen (Client → Server mit Ack), Payload: WebResizePayload */
+    readonly webResize: 'web:resize';
+    /** Handshake eines Agenten (Agent → Server mit Ack AgentHelloResult), Payload: AgentHelloInput */
+    readonly agentHello: 'agent:hello';
+    /** Laufbefehl mit serverseitiger Wegfindung (Agent → Server mit Ack), Payload: AgentGoToInput */
+    readonly agentGoTo: 'agent:goTo';
+    /** LiveKit-Token für den Raum, in dem der Agent steht (Agent → Server mit Ack MeetingTokenDto) */
+    readonly agentMeetingToken: 'agent:meetingToken';
+    /** Mensch spricht einen Agenten an (Browser → Server mit Ack), Payload: agentInvokeSchema */
+    readonly agentInvoke: 'agent:invoke';
+    /** Der Agent meldet, was er gerade tut (Agent → Server mit Ack), Payload: agentVoiceStateSchema */
+    readonly agentVoiceState: 'agent:voice:state';
+    /** Mensch beendet das Sprachgespräch (Browser → Server mit Ack), Payload: voiceCloseSchema */
+    readonly voiceClose: 'voice:close';
+    /** Chat-Nachricht senden (Client → Server mit Ack ChatMessageDto), Payload: sendMessageSchema – der Weg für Agenten */
+    readonly chatSend: 'chat:send';
+    /** „Schreibt gerade“ melden (Client → Server, ohne Ack), Payload: chatTypingSchema – Menschen und Agenten (SPA-133) */
+    readonly chatTyping: 'chat:typing';
+    readonly presenceJoined: 'presence:joined';
+    readonly presenceLeft: 'presence:left';
+    readonly sessionRevoked: 'session:revoked';
+    readonly worldTick: 'world:tick';
+    readonly worldParticipantJoined: 'world:participantJoined';
+    readonly worldParticipantLeft: 'world:participantLeft';
+    readonly worldPresence: 'world:presence';
+    /** Dieselbe Person ist woanders beigetreten – diese Verbindung wird abgelöst (SPA-104) */
+    readonly worldSuperseded: 'world:superseded';
+    readonly worldSeat: 'world:seat';
+    readonly worldCorrect: 'world:correct';
+    /** Neue Office-Revision veröffentlicht (Payload: OfficePublishedPayload) */
+    readonly officePublished: 'office:published';
+    /** Arbeitsplatzzuweisungen geändert (Payload: { assignments: DeskAssignmentDto[] }) */
+    readonly officeAssignments: 'office:assignments';
+    /** Entwurf geändert (Payload: OfficeDraftChangedPayload) – für parallel geöffnete Editoren */
+    readonly officeDraftChanged: 'office:draftChanged';
+    /** Avatar-Profil eines Teilnehmers geändert (Payload: WorldAvatarPayload) */
+    readonly worldAvatar: 'world:avatar';
+    /** Einmalige Geste eines Teilnehmers (Payload: WorldEmotePayload) */
+    readonly worldEmote: 'world:emote';
+    /** Persönliche Einrichtung eines Schreibtischs geändert (Payload: OfficeDeskPayload) */
+    readonly officeDesk: 'office:desk';
+    /** Inventar eines Mitglieds geändert (Payload: { workspaceId, userId }) – Client lädt sein Inventar neu */
+    readonly officeInventory: 'office:inventory';
+    /** Zone eines Teilnehmers geändert (Payload: WorldZonePayload) */
+    readonly worldZone: 'world:zone';
+    /** Es klopft an einer privaten Zone (Payload: ZoneKnockedPayload) – nur an Hosts in der Zone */
+    readonly zoneKnocked: 'zone:knocked';
+    /** Antwort auf das eigene Klopfen (Payload: ZoneAdmittedPayload) */
+    readonly zoneAdmitted: 'zone:admitted';
+    /** Dauerhafte oder sitzungsweite Freigaben einer Zone geändert (Payload: ZoneAccessPayload) */
+    readonly zoneAccess: 'zone:access';
+    /** Neue Chat-Nachricht (Payload: ChatMessagePayload) */
+    readonly chatMessage: 'chat:message';
+    /** Reaktionen einer Nachricht geändert (Payload: ChatReactionPayload) */
+    readonly chatReaction: 'chat:reaction';
+    /** Jemand schreibt gerade bzw. nicht mehr (Payload: ChatTypingPayload) – verfällt beim Empfänger nach CHAT_TYPING_TTL_MS */
+    readonly chatTypingUpdate: 'chat:typingUpdate';
+    /** Der Nutzer wurde aus dem Workspace entfernt (Payload: { workspaceId }) – Client verlässt das Office */
+    readonly workspaceRemoved: 'workspace:removed';
+    /** Workspace-Einstellungen geändert (Payload: WorkspaceSettingsPayload, SPA-125) */
+    readonly workspaceSettings: 'workspace:settings';
+    /** Fortschritt eines KI-Generator-Jobs (Payload: GeneratorProgressPayload) – an den Workspace-Raum */
+    readonly generatorProgress: 'generator:progress';
+    /** Neues Bild der Web-Anzeige (Payload: WebFramePayload) – nur an Abonnenten */
+    readonly webFrame: 'web:frame';
+    /** Zustand der Web-Anzeige (Payload: WebStatusPayload) – Laden, Fehler, Adresse, Steuerung */
+    readonly webStatus: 'web:status';
+    /** Jemand spricht den Agenten an (Payload: AgentAddressPayload) – nur an den betroffenen Agenten */
+    readonly agentAddress: 'agent:address';
+    /** Der Agent wurde gedrosselt (Payload: AgentThrottledPayload) */
+    readonly agentThrottled: 'agent:throttled';
+    /** Token rotiert, Agent deaktiviert oder gelöscht (Payload: AgentRevokedPayload) – Verbindung endet danach */
+    readonly agentRevoked: 'agent:revoked';
+    /** Sprachgespräch eröffnet oder beendet (Payload: AgentVoicePayload) – nur an den betroffenen Agenten (SPA-83) */
+    readonly agentVoice: 'agent:voice';
+    /** Gesprächszustand für die Oberfläche (Payload: VoiceSessionPayload) – an den Workspace-Raum (SPA-83) */
+    readonly voiceSession: 'voice:session';
+};
+export interface SocketAck<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface PresencePayload {
+    workspaceId: string;
+    userId: string;
+    displayName: string;
+}
+export declare function workspaceRoom(workspaceId: string): string;
+/** Socket-Raum eines Nutzers (alle seine Verbindungen) – Direktnachrichten, Einlass, Entfernen */
+export declare function userRoom(userId: string): string;
+/** Animationszustand; `sit` wird nur vom Server gesetzt (Sitzplatz belegt). */
+export type AnimState = 'idle' | 'walk' | 'run' | 'sit';
+export declare const MOVE_ANIMS: readonly ['idle', 'walk', 'run'];
+export interface ParticipantState {
+    /** Stabil über Reconnects hinweg (vom Client erzeugt, an den Nutzer gebunden) */
+    id: string;
+    userId: string;
+    displayName: string;
+    x: number;
+    z: number;
+    /** Blickrichtung in Grad um die Hochachse */
+    rotY: number;
+    anim: AnimState;
+    seatId: string | null;
+    /** false, solange die Verbindung unterbrochen ist (Grace-Period läuft) */
+    connected: boolean;
+    /** Avatar-Profil (Phase 4) */
+    avatar: AvatarProfile;
+    /** Zone, in der der Teilnehmer steht (Phase 5); null = außerhalb aller Zonen */
+    zoneId: string | null;
+    /** Medienstatus (Phase 5), vom Client gemeldet */
+    media: MediaState;
+    /** Mensch oder KI-Agent (SPA-66); fehlt bei alten Snapshots und gilt dann als 'user' */
+    kind?: 'user' | 'agent';
+    /** Kennzeichnung eines Agenten (SPA-66) – die UI zeigt Badge, Kartenmarker und Chat-Hinweis daraus */
+    agent?: AgentBadge;
+}
+/** Präsenzstatus, vom Nutzer gesetzt (Design: Frei / Fokus / Weg) */
+export type PresenceStatus = 'frei' | 'fokus' | 'weg';
+/** Medienstatus eines Teilnehmers (Phase 5). `screen` = teilt gerade den Bildschirm. */
+export interface MediaState {
+    mic: boolean;
+    cam: boolean;
+    screen: boolean;
+    presence: PresenceStatus;
+}
+export interface WorldJoinPayload {
+    workspaceId: string;
+    /** Bei Reconnect: bisherige Teilnehmer-ID, um Position/Sitzplatz zu behalten */
+    participantId?: string;
+}
+export interface WorldSnapshot {
+    workspaceId: string;
+    officeId: string;
+    revisionId: string;
+    /** Letzte Tick-Sequenznummer der Welt; ältere Ticks nach dem Snapshot ignorieren */
+    seq: number;
+    serverTime: number;
+    self: string;
+    participants: ParticipantState[];
+    /** Serverseitige Parameter, damit der Client dieselben Grenzen nutzt */
+    tickHz: number;
+    graceMs: number;
+    /** Freigaben privater Zonen (Phase 5) */
+    zoneAccess: ZoneAccessPayload[];
+    /** Zustände interaktiver Objekte (Phase 7): Instanz-ID → Zustand */
+    objects: Record<string, ObjectStateValue>;
+}
+export interface WorldMovePayload {
+    /** Monotone Client-Sequenz; der Server verwirft ältere/duplizierte Pakete */
+    seq: number;
+    x: number;
+    z: number;
+    rotY: number;
+    anim: (typeof MOVE_ANIMS)[number];
+    /** Client-Zeitstempel (performance.now), wird im Tick für den Sender zurückgegeben */
+    t?: number;
+}
+/** Kompaktes Update: [participantId, x, z, rotY, anim, clientSeq, clientT] */
+export type TickUpdate = [string, number, number, number, AnimState, number, number];
+export interface WorldTickPayload {
+    seq: number;
+    t: number;
+    u: TickUpdate[];
+}
+export interface WorldCorrectPayload {
+    x: number;
+    z: number;
+    rotY: number;
+    anim: AnimState;
+    seatId: string | null;
+    reason: 'speed' | 'collision' | 'seated' | 'invalid' | 'private' | 'full';
+}
+export interface WorldSeatPayload {
+    participantId: string;
+    seatId: string | null;
+    x: number;
+    z: number;
+    rotY: number;
+    anim: AnimState;
+}
+export interface WorldPresencePayload {
+    participantId: string;
+    connected: boolean;
+}
+/**
+ * Ein Nutzer, ein Avatar (SPA-104): dieselbe Person ist in einem anderen Fenster, Tab oder Gerät
+ * beigetreten. Diese Verbindung hat die Welt verlassen und baut bewusst keinen Reconnect auf.
+ */
+export interface WorldSupersededPayload {
+    workspaceId: string;
+    /** Zeitpunkt der Übernahme */
+    at: number;
+}
+export interface WorldSitPayload {
+    seatId: string;
+}
+export interface OfficePublishedPayload {
+    workspaceId: string;
+    officeId: string;
+    revisionId: string;
+    number: number;
+    publishedAt: string;
+    by: {
+        userId: string;
+        displayName: string;
+    };
+}
+export interface OfficeDraftChangedPayload {
+    workspaceId: string;
+    officeId: string;
+    version: number;
+    by: {
+        userId: string;
+        displayName: string;
+    };
+    /** 'op' = Operation angewendet, 'reset' = Entwurf verworfen/neu aufgesetzt, 'lock' = Sperre geändert */
+    kind: 'op' | 'reset' | 'lock';
+}
+export interface WorldAvatarPayload {
+    participantId: string;
+    avatar: AvatarProfile;
+}
+/** `wave` = Wink-Clip (Phase 4); `glyph` = Reaktion/Objekt-Emote über dem Kopf (Phase 7) */
+export type Emote = 'wave' | 'glyph';
+export interface WorldEmotePayload {
+    participantId: string;
+    emote: Emote;
+    /** Glyph über dem Kopf (Phase 7); beim Winken 👋 */
+    glyph?: string;
+    /** Auslösendes Objekt (Phase 7c) */
+    objectId?: string;
+}
+/** Objektzustand: flaches JSON ≤ 2 KB (Lampe `{ on: false }`, später weitere) */
+export type ObjectStateValue = Record<string, unknown>;
+export interface ObjectStatePayload {
+    placementId: string;
+    state: ObjectStateValue;
+    /** Monoton je Objekt (Server); veraltete Broadcasts ignorieren */
+    version: number;
+    /** Teilnehmer, der den Zustand gesetzt hat (fehlt beim Snapshot) */
+    by?: string;
+}
+export interface ObjectActionPayload {
+    placementId: string;
+    action: string;
+    data?: unknown;
+    /** Auslösender Teilnehmer (Server → Client) */
+    participantId: string;
+    /** Serverseitiger Zufallswert (Katalog `action.roll`), z. B. Dart-Wurf */
+    roll?: number;
+    /** Serverzeit der Aktion */
+    at: number;
+}
+export interface BoardOpPayload {
+    placementId: string;
+    version: number;
+    /** BoardOp aus @huddle/shared (board.ts) */
+    op: unknown;
+    by: string;
+}
+export interface BoardSyncPayload {
+    placementId: string;
+    version: number;
+    /** Snapshot-PNG als data:-URL (null = leeres Board) und seine Version */
+    snapshot: string | null;
+    snapshotVersion: number;
+    /** Operationen seit dem Snapshot (in Reihenfolge) */
+    ops: Array<{
+        v: number;
+        op: unknown;
+        by: string;
+    }>;
+}
+export interface BoardCursorPayload {
+    placementId: string;
+    participantId: string;
+    displayName: string;
+    /** Normiert 0–1; null = Zeiger verlassen */
+    x: number | null;
+    y: number | null;
+}
+export interface OfficeDeskPayload {
+    workspaceId: string;
+    officeId: string;
+    deskId: string;
+    /** null = Einrichtung entfernt (Zurücksetzen, Platz neu vergeben, Schreibtisch weg) */
+    customization: DeskCustomizationDto | null;
+}
+export interface WorldZonePayload {
+    participantId: string;
+    zoneId: string | null;
+}
+export interface WorldMediaPayload extends MediaState {
+    participantId: string;
+}
+export interface ZoneKnockPayload {
+    zoneId: string;
+}
+export interface ZoneAdmitPayload {
+    zoneId: string;
+    userId: string;
+    allow: boolean;
+}
+export interface ZoneKnockedPayload {
+    zoneId: string;
+    userId: string;
+    displayName: string;
+}
+export interface ZoneAdmittedPayload {
+    zoneId: string;
+    allowed: boolean;
+    by: {
+        userId: string;
+        displayName: string;
+    };
+}
+/** Freigaben einer privaten Zone: dauerhaft (`persistent`, per HTTP verwaltet) und für diese Sitzung der Welt (`session`, per Einlass) */
+export interface ZoneAccessPayload {
+    workspaceId: string;
+    zoneId: string;
+    persistent: string[];
+    session: string[];
+}
+export interface ChatMessagePayload {
+    workspaceId: string;
+    message: ChatMessageDto;
+}
+/** Wie lange eine „schreibt“-Meldung gilt, wenn keine Auffrischung kommt (SPA-133). Sender frischen alle ~3 s auf. */
+export declare const CHAT_TYPING_TTL_MS = 6000;
+export declare const CHAT_TYPING_REFRESH_MS = 3000;
+export interface ChatTypingPayload {
+    workspaceId: string;
+    conv: string;
+    /** Thread, in dem geschrieben wird – `null` für den Kanal selbst */
+    parentId: string | null;
+    userId: string;
+    name: string;
+    kind: 'user' | 'agent';
+    typing: boolean;
+}
+export interface ChatReactionPayload {
+    workspaceId: string;
+    conv: string;
+    messageId: string;
+    reactions: ChatReactionDto[];
+}