@noematicsllc/talk-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,1864 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActorType: () => ActorType,
+  BreakoutRoomMode: () => BreakoutRoomMode,
+  CallResource: () => CallResource,
+  ChatResource: () => ChatResource,
+  ConversationType: () => ConversationType,
+  HttpClient: () => HttpClient,
+  HttpClientError: () => HttpClientError,
+  InCallFlag: () => InCallFlag,
+  ListableScope: () => ListableScope,
+  LobbyState: () => LobbyState,
+  MessageType: () => MessageType,
+  NotificationLevel: () => NotificationLevel,
+  ParticipantResource: () => ParticipantResource,
+  ParticipantType: () => ParticipantType,
+  Permission: () => Permission,
+  PollResource: () => PollResource,
+  PollResultMode: () => PollResultMode,
+  ReactionResource: () => ReactionResource,
+  ReadOnlyState: () => ReadOnlyState,
+  RecordingStatus: () => RecordingStatus,
+  Room: () => Room,
+  RoomResource: () => RoomResource,
+  RoomsAccessor: () => RoomsAccessor,
+  SIPState: () => SIPState,
+  SharedObjectType: () => SharedObjectType,
+  TalkClient: () => TalkClient,
+  normalizeMessage: () => normalizeMessage,
+  normalizeMessageWithParent: () => normalizeMessageWithParent,
+  normalizeMessages: () => normalizeMessages,
+  normalizeParticipant: () => normalizeParticipant,
+  normalizeParticipants: () => normalizeParticipants,
+  normalizeRoom: () => normalizeRoom,
+  normalizeRooms: () => normalizeRooms
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/transport/http-client.ts
+var HttpClientError = class extends Error {
+  constructor(message, status, ocsStatus, ocsMessage) {
+    super(message);
+    this.status = status;
+    this.ocsStatus = ocsStatus;
+    this.ocsMessage = ocsMessage;
+    this.name = "HttpClientError";
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  authHeader;
+  fetchImpl;
+  constructor(config) {
+    this.baseUrl = config.host.replace(/\/$/, "");
+    const credentials = `${config.username}:${config.password}`;
+    const encoded = typeof btoa === "function" ? btoa(credentials) : Buffer.from(credentials).toString("base64");
+    this.authHeader = `Basic ${encoded}`;
+    const globalFetch = globalThis.fetch;
+    this.fetchImpl = config.fetch ?? (globalFetch ? globalFetch.bind(globalThis) : void 0);
+    if (!this.fetchImpl) {
+      throw new Error("Fetch API is not available. Please provide a fetch implementation.");
+    }
+  }
+  /**
+   * Build the full URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Extract Nextcloud-specific headers from response
+   */
+  extractMeta(headers) {
+    const meta = {};
+    const talkHash = headers.get("X-Nextcloud-Talk-Hash");
+    if (talkHash) meta.talkHash = talkHash;
+    const modifiedBefore = headers.get("X-Nextcloud-Talk-Modified-Before");
+    if (modifiedBefore) meta.modifiedBefore = parseInt(modifiedBefore, 10);
+    const chatLastGiven = headers.get("X-Chat-Last-Given");
+    if (chatLastGiven) meta.chatLastGiven = parseInt(chatLastGiven, 10);
+    const chatLastCommonRead = headers.get("X-Chat-Last-Common-Read");
+    if (chatLastCommonRead) meta.chatLastCommonRead = parseInt(chatLastCommonRead, 10);
+    const federationInvites = headers.get("X-Nextcloud-Talk-Federation-Invites");
+    if (federationInvites) meta.federationInvites = parseInt(federationInvites, 10);
+    return meta;
+  }
+  /**
+   * Make an HTTP request to the Nextcloud OCS API
+   *
+   * @param path - API path (e.g., '/ocs/v2.php/apps/spreed/api/v4/room')
+   * @param options - Request options
+   * @returns Promise resolving to the unwrapped OCS data
+   *
+   * @throws {HttpClientError} When the request fails or returns an error status
+   *
+   * @remarks
+   * OCS API returns status codes in the response body:
+   * - 100: Success (OCS v1)
+   * - 200: Success (OCS v2)
+   * - Other codes indicate errors specific to the endpoint
+   */
+  async request(path, options = {}) {
+    const {
+      method = "GET",
+      body,
+      params,
+      headers: customHeaders = {},
+      timeout = 3e4
+    } = options;
+    const url = this.buildUrl(path, params);
+    const headers = {
+      "OCS-APIRequest": "true",
+      "Accept": "application/json",
+      "Authorization": this.authHeader,
+      ...customHeaders
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (response.status === 304) {
+        return {
+          data: [],
+          status: response.status,
+          meta: this.extractMeta(response.headers),
+          headers: response.headers
+        };
+      }
+      if (!response.ok) {
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        let ocsStatus;
+        let ocsMessage;
+        try {
+          const errorBody = await response.json();
+          ocsStatus = errorBody.ocs?.meta?.statuscode;
+          ocsMessage = errorBody.ocs?.meta?.message;
+          if (ocsMessage) {
+            errorMessage = `${errorMessage} - ${ocsMessage}`;
+          }
+        } catch {
+        }
+        throw new HttpClientError(errorMessage, response.status, ocsStatus, ocsMessage);
+      }
+      const json = await response.json();
+      if (!json.ocs) {
+        throw new HttpClientError("Invalid OCS response: missing ocs envelope", response.status);
+      }
+      return {
+        data: json.ocs.data,
+        status: response.status,
+        meta: this.extractMeta(response.headers),
+        headers: response.headers
+      };
+    } catch (error) {
+      if (error instanceof HttpClientError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new HttpClientError("Request timeout", 408);
+      }
+      throw new HttpClientError(
+        error instanceof Error ? error.message : "Unknown error",
+        0
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /** GET request helper */
+  async get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  /** POST request helper */
+  async post(path, body, params) {
+    return this.request(path, { method: "POST", body, params });
+  }
+  /** PUT request helper */
+  async put(path, body, params) {
+    return this.request(path, { method: "PUT", body, params });
+  }
+  /** DELETE request helper */
+  async delete(path, params) {
+    return this.request(path, { method: "DELETE", params });
+  }
+  /** Get the base URL for this client */
+  get host() {
+    return this.baseUrl;
+  }
+};
+
+// src/normalization/room-mapper.ts
+function normalizeRoom(raw) {
+  return {
+    // Identifiers
+    id: raw.id,
+    token: raw.token,
+    // Basic info
+    type: raw.type,
+    name: raw.name,
+    displayName: raw.displayName,
+    description: raw.description,
+    // Current user context
+    actorType: raw.actorType,
+    actorId: raw.actorId,
+    attendeeId: raw.attendeeId,
+    participantType: raw.participantType,
+    permissions: raw.permissions,
+    attendeePermissions: raw.attendeePermissions,
+    // Room state
+    hasPassword: raw.hasPassword,
+    hasCall: raw.hasCall,
+    callFlag: raw.callFlag,
+    callStartTime: raw.callStartTime,
+    callRecording: raw.callRecording,
+    // Settings
+    readOnly: raw.readOnly,
+    listable: raw.listable,
+    lobbyState: raw.lobbyState,
+    lobbyTimer: raw.lobbyTimer,
+    sipEnabled: raw.sipEnabled,
+    mentionPermissions: raw.mentionPermissions,
+    messageExpiration: raw.messageExpiration,
+    recordingConsent: raw.recordingConsent,
+    // Chat state
+    lastActivity: raw.lastActivity,
+    lastReadMessage: raw.lastReadMessage,
+    lastCommonReadMessage: raw.lastCommonReadMessage,
+    unreadMessages: raw.unreadMessages,
+    unreadMention: raw.unreadMention,
+    unreadMentionDirect: raw.unreadMentionDirect,
+    // Capabilities
+    canStartCall: raw.canStartCall,
+    canLeaveConversation: raw.canLeaveConversation,
+    canDeleteConversation: raw.canDeleteConversation,
+    canEnableSIP: raw.canEnableSIP,
+    // Flags
+    isFavorite: raw.isFavorite,
+    isArchived: raw.isArchived,
+    isImportant: raw.isImportant,
+    isSensitive: raw.isSensitive,
+    // Optional status
+    status: raw.status,
+    statusIcon: raw.statusIcon,
+    statusMessage: raw.statusMessage,
+    statusClearAt: raw.statusClearAt,
+    // Federation
+    remoteServer: raw.remoteServer,
+    remoteToken: raw.remoteToken
+  };
+}
+function normalizeRooms(rawRooms) {
+  return rawRooms.map(normalizeRoom);
+}
+
+// src/normalization/message-mapper.ts
+function isDeletedRef(parent) {
+  return "deleted" in parent && parent.deleted === true;
+}
+function normalizeMessage(raw) {
+  return {
+    id: raw.id,
+    token: raw.token,
+    actorType: raw.actorType,
+    actorId: raw.actorId,
+    actorDisplayName: raw.actorDisplayName,
+    timestamp: raw.timestamp,
+    message: raw.message,
+    messageType: raw.messageType,
+    systemMessage: raw.systemMessage,
+    messageParameters: raw.messageParameters,
+    // Features
+    isReplyable: raw.isReplyable,
+    markdown: raw.markdown,
+    referenceId: raw.referenceId,
+    expirationTimestamp: raw.expirationTimestamp,
+    // Reactions
+    reactions: raw.reactions,
+    reactionsSelf: raw.reactionsSelf ?? [],
+    // Editing
+    lastEditActorType: raw.lastEditActorType,
+    lastEditActorId: raw.lastEditActorId,
+    lastEditActorDisplayName: raw.lastEditActorDisplayName,
+    lastEditTimestamp: raw.lastEditTimestamp,
+    // Threads
+    threadId: raw.threadId,
+    isThread: raw.isThread ?? false,
+    threadTitle: raw.threadTitle,
+    threadReplies: raw.threadReplies,
+    // Metadata
+    metaData: raw.metaData
+  };
+}
+function normalizeMessageWithParent(raw) {
+  const normalized = normalizeMessage(raw);
+  if (raw.parent) {
+    if (isDeletedRef(raw.parent)) {
+      normalized.parent = { id: raw.parent.id, deleted: true };
+    } else {
+      normalized.parent = normalizeMessage(raw.parent);
+    }
+  }
+  return normalized;
+}
+function normalizeMessages(rawMessages) {
+  return rawMessages.map(normalizeMessageWithParent);
+}
+
+// src/normalization/participant-mapper.ts
+function normalizeParticipant(raw) {
+  return {
+    actorType: raw.actorType,
+    actorId: raw.actorId,
+    displayName: raw.displayName,
+    attendeeId: raw.attendeeId,
+    participantType: raw.participantType,
+    permissions: raw.permissions,
+    attendeePermissions: raw.attendeePermissions,
+    attendeePin: raw.attendeePin,
+    roomToken: raw.roomToken,
+    sessionIds: raw.sessionIds,
+    inCall: raw.inCall,
+    lastPing: raw.lastPing,
+    // Status
+    status: raw.status,
+    statusIcon: raw.statusIcon,
+    statusMessage: raw.statusMessage,
+    statusClearAt: raw.statusClearAt,
+    // Phone
+    phoneNumber: raw.phoneNumber,
+    callId: raw.callId,
+    // Computed helpers (based on InCallFlag enum values)
+    isInCall: (raw.inCall & 1) !== 0,
+    // IN_CALL = 1
+    hasAudio: (raw.inCall & 2) !== 0,
+    // WITH_AUDIO = 2
+    hasVideo: (raw.inCall & 4) !== 0,
+    // WITH_VIDEO = 4
+    isOnPhone: (raw.inCall & 8) !== 0
+    // WITH_PHONE = 8
+  };
+}
+function normalizeParticipants(rawParticipants) {
+  return rawParticipants.map(normalizeParticipant);
+}
+
+// src/resources/room-resource.ts
+var BASE_PATH = "/ocs/v2.php/apps/spreed/api/v4/room";
+var RoomResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all conversations the current user is part of
+   *
+   * @param options - List options (includeStatus, modifiedSince, etc.)
+   * @returns Array of normalized room objects
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 200: Success
+   */
+  async list(options = {}) {
+    const response = await this.http.get(BASE_PATH, {
+      noStatusUpdate: options.noStatusUpdate ? 1 : void 0,
+      includeStatus: options.includeStatus,
+      modifiedSince: options.modifiedSince,
+      includeLastMessage: options.includeLastMessage
+    });
+    return normalizeRooms(response.data);
+  }
+  /**
+   * Get a single room by token
+   *
+   * @param token - Room token
+   * @returns Normalized room object
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 200: Success
+   * - 401: Unauthorized
+   * - 404: Room not found
+   */
+  async get(token) {
+    const response = await this.http.get(`${BASE_PATH}/${token}`);
+    return normalizeRoom(response.data);
+  }
+  /**
+   * Create a new room
+   *
+   * @param options - Room creation options
+   * @returns Created room object
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 200: Existing room returned (for 1-1 conversations)
+   * - 201: Room created
+   * - 202: Room created with invalid invitations
+   */
+  async create(options) {
+    const response = await this.http.post(BASE_PATH, options);
+    return normalizeRoom(response.data);
+  }
+  /**
+   * Update room name
+   *
+   * @param token - Room token
+   * @param roomName - New room name
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async rename(token, roomName) {
+    await this.http.put(`${BASE_PATH}/${token}`, { roomName });
+  }
+  /**
+   * Update room description
+   *
+   * @param token - Room token
+   * @param description - New description (max 2000 chars)
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async setDescription(token, description) {
+    await this.http.put(`${BASE_PATH}/${token}/description`, { description });
+  }
+  /**
+   * Delete a room
+   *
+   * @param token - Room token
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async delete(token) {
+    await this.http.delete(`${BASE_PATH}/${token}`);
+  }
+  /**
+   * Set room password
+   *
+   * @param token - Room token
+   * @param password - Room password (empty string to remove)
+   *
+   * @remarks
+   * Requires moderator permissions. Only for public rooms.
+   */
+  async setPassword(token, password) {
+    await this.http.put(`${BASE_PATH}/${token}/password`, { password });
+  }
+  /**
+   * Make room public (allow guests)
+   *
+   * @param token - Room token
+   *
+   * @remarks
+   * Requires logged-in moderator.
+   */
+  async makePublic(token) {
+    await this.http.post(`${BASE_PATH}/${token}/public`);
+  }
+  /**
+   * Make room private
+   *
+   * @param token - Room token
+   *
+   * @remarks
+   * Requires logged-in moderator.
+   */
+  async makePrivate(token) {
+    await this.http.delete(`${BASE_PATH}/${token}/public`);
+  }
+  /**
+   * Set read-only state
+   *
+   * @param token - Room token
+   * @param state - Read-only state (0 = read-write, 1 = read-only)
+   */
+  async setReadOnly(token, state) {
+    await this.http.put(`${BASE_PATH}/${token}/read-only`, { state });
+  }
+  /**
+   * Set listable scope
+   *
+   * @param token - Room token
+   * @param scope - Listable scope (0 = none, 1 = users, 2 = everyone)
+   */
+  async setListable(token, scope) {
+    await this.http.put(`${BASE_PATH}/${token}/listable`, { scope });
+  }
+  /**
+   * Add room to favorites
+   *
+   * @param token - Room token
+   */
+  async addToFavorites(token) {
+    await this.http.post(`${BASE_PATH}/${token}/favorite`);
+  }
+  /**
+   * Remove room from favorites
+   *
+   * @param token - Room token
+   */
+  async removeFromFavorites(token) {
+    await this.http.delete(`${BASE_PATH}/${token}/favorite`);
+  }
+  /**
+   * Archive room
+   *
+   * @param token - Room token
+   */
+  async archive(token) {
+    await this.http.post(`${BASE_PATH}/${token}/archive`);
+  }
+  /**
+   * Unarchive room
+   *
+   * @param token - Room token
+   */
+  async unarchive(token) {
+    await this.http.delete(`${BASE_PATH}/${token}/archive`);
+  }
+  /**
+   * Mark room as important (notifications on DND)
+   *
+   * @param token - Room token
+   */
+  async markImportant(token) {
+    await this.http.post(`${BASE_PATH}/${token}/important`);
+  }
+  /**
+   * Unmark room as important
+   *
+   * @param token - Room token
+   */
+  async unmarkImportant(token) {
+    await this.http.delete(`${BASE_PATH}/${token}/important`);
+  }
+  /**
+   * Mark room as sensitive (hide preview)
+   *
+   * @param token - Room token
+   */
+  async markSensitive(token) {
+    await this.http.post(`${BASE_PATH}/${token}/sensitive`);
+  }
+  /**
+   * Unmark room as sensitive
+   *
+   * @param token - Room token
+   */
+  async unmarkSensitive(token) {
+    await this.http.delete(`${BASE_PATH}/${token}/sensitive`);
+  }
+  /**
+   * Set notification level
+   *
+   * @param token - Room token
+   * @param level - Notification level (0-3)
+   */
+  async setNotificationLevel(token, level) {
+    await this.http.post(`${BASE_PATH}/${token}/notify`, { level });
+  }
+  /**
+   * Set call notification setting
+   *
+   * @param token - Room token
+   * @param level - Call notification level (0 = off, 1 = on)
+   */
+  async setCallNotifications(token, level) {
+    await this.http.post(`${BASE_PATH}/${token}/notify-calls`, { level });
+  }
+  /**
+   * Configure lobby
+   *
+   * @param token - Room token
+   * @param state - Lobby state (0 = disabled, 1 = enabled)
+   * @param timer - Optional Unix timestamp when lobby opens
+   */
+  async setLobby(token, state, timer) {
+    await this.http.put(`${BASE_PATH}/${token}/webinar/lobby`, { state, timer });
+  }
+  /**
+   * Set default or call permissions for the room
+   *
+   * @param token - Room token
+   * @param mode - Permission mode ('default' or 'call')
+   * @param permissions - Permission bitmask
+   */
+  async setPermissions(token, mode, permissions) {
+    await this.http.put(`${BASE_PATH}/${token}/permissions/${mode}`, { permissions });
+  }
+  /**
+   * Set message expiration time
+   *
+   * @param token - Room token
+   * @param seconds - Expiration time in seconds (0 = never)
+   */
+  async setMessageExpiration(token, seconds) {
+    await this.http.post(`${BASE_PATH}/${token}/message-expiration`, { seconds });
+  }
+  /**
+   * Get raw response with metadata headers (for advanced use)
+   *
+   * @param token - Room token
+   * @returns Full HTTP response with data and metadata
+   */
+  async getRaw(token) {
+    return this.http.get(`${BASE_PATH}/${token}`);
+  }
+};
+
+// src/resources/chat-resource.ts
+var BASE_PATH2 = "/ocs/v2.php/apps/spreed/api/v1/chat";
+var ChatResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Receive messages from a room
+   *
+   * @param token - Room token
+   * @param options - Receive options (lookIntoFuture, limit, lastKnownMessageId, etc.)
+   * @returns Array of normalized messages
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 200: Messages returned
+   * - 304: No new messages (long-poll timeout)
+   */
+  async receiveMessages(token, options) {
+    const response = await this.http.get(
+      `${BASE_PATH2}/${token}`,
+      {
+        lookIntoFuture: options.lookIntoFuture,
+        limit: options.limit,
+        lastKnownMessageId: options.lastKnownMessageId,
+        timeout: options.timeout,
+        setReadMarker: options.setReadMarker === false ? 0 : 1,
+        includeLastKnown: options.includeLastKnown ? 1 : 0,
+        markNotificationsAsRead: options.markNotificationsAsRead === false ? 0 : 1,
+        threadId: options.threadId
+      }
+    );
+    return normalizeMessages(response.data);
+  }
+  /**
+   * Get message history (past messages)
+   *
+   * @param token - Room token
+   * @param options - Optional limit and lastKnownMessageId for pagination
+   * @returns Array of normalized messages
+   */
+  async getHistory(token, options = {}) {
+    return this.receiveMessages(token, {
+      lookIntoFuture: 0,
+      ...options
+    });
+  }
+  /**
+   * Poll for new messages (long-polling)
+   *
+   * This implements the spec's efficient update pattern for receiving
+   * new messages. The server holds the connection for up to `timeout` seconds.
+   *
+   * @param token - Room token
+   * @param options - Poll options with required lastKnownMessageId
+   * @returns Poll result with messages and metadata for next poll
+   *
+   * @example
+   * ```ts
+   * let lastKnownMessageId = 0;
+   *
+   * while (polling) {
+   *   const result = await chat.pollMessages(token, { lastKnownMessageId });
+   *   for (const message of result.messages) {
+   *     console.log(message.message);
+   *   }
+   *   if (result.lastKnownMessageId) {
+   *     lastKnownMessageId = result.lastKnownMessageId;
+   *   }
+   * }
+   * ```
+   */
+  async pollMessages(token, options) {
+    const response = await this.http.request(
+      `${BASE_PATH2}/${token}`,
+      {
+        method: "GET",
+        params: {
+          lookIntoFuture: 1,
+          limit: options.limit ?? 100,
+          lastKnownMessageId: options.lastKnownMessageId,
+          timeout: options.timeout ?? 30,
+          threadId: options.threadId
+        },
+        timeout: ((options.timeout ?? 30) + 5) * 1e3
+        // Add buffer to server timeout
+      }
+    );
+    return {
+      messages: normalizeMessages(response.data),
+      lastKnownMessageId: response.meta.chatLastGiven,
+      lastCommonRead: response.meta.chatLastCommonRead
+    };
+  }
+  /**
+   * Send a message to a room
+   *
+   * @param token - Room token
+   * @param options - Message options
+   * @returns Sent message
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 201: Message sent
+   * - 400: Sending not possible
+   * - 404: Actor not found
+   * - 413: Message too long (max 32000 chars)
+   * - 429: Mention rate limit exceeded
+   */
+  async sendMessage(token, options) {
+    const response = await this.http.post(
+      `${BASE_PATH2}/${token}`,
+      {
+        message: options.message,
+        actorDisplayName: options.actorDisplayName,
+        referenceId: options.referenceId,
+        replyTo: options.replyTo,
+        silent: options.silent,
+        threadId: options.threadId,
+        threadTitle: options.threadTitle
+      }
+    );
+    return normalizeMessageWithParent(response.data);
+  }
+  /**
+   * Edit a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to edit
+   * @param message - New message content
+   * @returns Updated message
+   */
+  async editMessage(token, messageId, message) {
+    const response = await this.http.put(
+      `${BASE_PATH2}/${token}/${messageId}`,
+      { message }
+    );
+    return normalizeMessageWithParent(response.data);
+  }
+  /**
+   * Delete a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to delete
+   * @returns Deleted message placeholder
+   */
+  async deleteMessage(token, messageId) {
+    const response = await this.http.delete(
+      `${BASE_PATH2}/${token}/${messageId}`
+    );
+    return normalizeMessageWithParent(response.data);
+  }
+  /**
+   * Get message context (surrounding messages)
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to get context for
+   * @param options - Optional limit and threadId
+   * @returns Array of messages around the target message
+   */
+  async getContext(token, messageId, options = {}) {
+    const response = await this.http.get(
+      `${BASE_PATH2}/${token}/${messageId}/context`,
+      {
+        limit: options.limit,
+        threadId: options.threadId
+      }
+    );
+    return normalizeMessages(response.data);
+  }
+  /**
+   * Share a rich object (file, deck card, etc.)
+   *
+   * @param token - Room token
+   * @param options - Share options
+   * @returns Shared message
+   */
+  async shareObject(token, options) {
+    const response = await this.http.post(
+      `${BASE_PATH2}/${token}/share`,
+      {
+        objectType: options.objectType,
+        objectId: options.objectId,
+        metaData: options.metaData,
+        referenceId: options.referenceId,
+        threadId: options.threadId
+      }
+    );
+    return normalizeMessageWithParent(response.data);
+  }
+  /**
+   * Clear chat history
+   *
+   * @param token - Room token
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async clearHistory(token) {
+    await this.http.delete(`${BASE_PATH2}/${token}`);
+  }
+  /**
+   * Set read marker to a specific message
+   *
+   * @param token - Room token
+   * @param lastReadMessage - Message ID to mark as last read
+   */
+  async setReadMarker(token, lastReadMessage) {
+    await this.http.post(`${BASE_PATH2}/${token}/read`, { lastReadMessage });
+  }
+  /**
+   * Mark chat as unread
+   *
+   * @param token - Room token
+   */
+  async markUnread(token) {
+    await this.http.delete(`${BASE_PATH2}/${token}/read`);
+  }
+  /**
+   * Search for mention suggestions
+   *
+   * @param token - Room token
+   * @param search - Search query
+   * @param options - Optional limit and includeStatus
+   * @returns Array of mention suggestions
+   */
+  async searchMentions(token, search, options = {}) {
+    const response = await this.http.get(
+      `${BASE_PATH2}/${token}/mentions`,
+      {
+        search,
+        limit: options.limit ?? 20,
+        includeStatus: options.includeStatus
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Pin a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to pin
+   * @param pinUntil - Optional Unix timestamp when pin expires
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async pinMessage(token, messageId, pinUntil) {
+    await this.http.post(`${BASE_PATH2}/${token}/${messageId}/pin`, { pinUntil });
+  }
+  /**
+   * Unpin a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to unpin
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async unpinMessage(token, messageId) {
+    await this.http.delete(`${BASE_PATH2}/${token}/${messageId}/pin`);
+  }
+  /**
+   * Hide a pinned message for the current user only
+   *
+   * @param token - Room token
+   * @param messageId - Message ID to hide
+   */
+  async hidePinnedMessage(token, messageId) {
+    await this.http.delete(`${BASE_PATH2}/${token}/${messageId}/pin/self`);
+  }
+  /**
+   * Set a reminder for a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID
+   * @param timestamp - Unix timestamp for reminder
+   */
+  async setReminder(token, messageId, timestamp) {
+    await this.http.post(`${BASE_PATH2}/${token}/${messageId}/reminder`, { timestamp });
+  }
+  /**
+   * Delete a message reminder
+   *
+   * @param token - Room token
+   * @param messageId - Message ID
+   */
+  async deleteReminder(token, messageId) {
+    await this.http.delete(`${BASE_PATH2}/${token}/${messageId}/reminder`);
+  }
+};
+
+// src/resources/participant-resource.ts
+var BASE_PATH3 = "/ocs/v2.php/apps/spreed/api/v4/room";
+var ParticipantResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get list of participants in a room
+   *
+   * @param token - Room token
+   * @param includeStatus - Include user status information
+   * @returns Array of normalized participants
+   */
+  async list(token, includeStatus = false) {
+    const response = await this.http.get(
+      `${BASE_PATH3}/${token}/participants`,
+      { includeStatus }
+    );
+    return normalizeParticipants(response.data);
+  }
+  /**
+   * Add a participant to a room
+   *
+   * @param token - Room token
+   * @param options - Participant options
+   *
+   * @remarks
+   * Requires logged-in moderator.
+   */
+  async add(token, options) {
+    await this.http.post(`${BASE_PATH3}/${token}/participants`, {
+      newParticipant: options.newParticipant,
+      source: options.source
+    });
+  }
+  /**
+   * Remove a participant from a room
+   *
+   * @param token - Room token
+   * @param attendeeId - Attendee ID to remove
+   *
+   * @remarks
+   * Requires moderator permissions.
+   */
+  async remove(token, attendeeId) {
+    await this.http.delete(`${BASE_PATH3}/${token}/attendees`, { attendeeId });
+  }
+  /**
+   * Remove self from a room
+   *
+   * @param token - Room token
+   */
+  async removeSelf(token) {
+    await this.http.delete(`${BASE_PATH3}/${token}/participants/self`);
+  }
+  /**
+   * Join a room (create session)
+   *
+   * @param token - Room token
+   * @param options - Join options
+   * @returns Room data after joining
+   *
+   * @remarks
+   * OCS Status Codes:
+   * - 200: Joined successfully
+   * - 409: Conflict - already joined on another device
+   *
+   * On 409, the response contains session conflict info.
+   */
+  async join(token, options = {}) {
+    const response = await this.http.post(
+      `${BASE_PATH3}/${token}/participants/active`,
+      {
+        password: options.password,
+        force: options.force
+      }
+    );
+    return normalizeRoom(response.data);
+  }
+  /**
+   * Leave a room (end session)
+   *
+   * @param token - Room token
+   */
+  async leave(token) {
+    await this.http.delete(`${BASE_PATH3}/${token}/participants/active`);
+  }
+  /**
+   * Set session state (active/inactive)
+   *
+   * @param token - Room token
+   * @param state - 0 = inactive, 1 = active
+   */
+  async setSessionState(token, state) {
+    await this.http.put(`${BASE_PATH3}/${token}/participants/state`, { state });
+  }
+  /**
+   * Promote a participant to moderator
+   *
+   * @param token - Room token
+   * @param attendeeId - Attendee ID to promote
+   */
+  async promoteModerator(token, attendeeId) {
+    await this.http.post(`${BASE_PATH3}/${token}/moderators`, { attendeeId });
+  }
+  /**
+   * Demote a moderator to regular participant
+   *
+   * @param token - Room token
+   * @param attendeeId - Attendee ID to demote
+   */
+  async demoteModerator(token, attendeeId) {
+    await this.http.delete(`${BASE_PATH3}/${token}/moderators`, { attendeeId });
+  }
+  /**
+   * Set permissions for an attendee
+   *
+   * @param token - Room token
+   * @param options - Permission options
+   */
+  async setPermissions(token, options) {
+    await this.http.put(`${BASE_PATH3}/${token}/attendees/permissions`, {
+      attendeeId: options.attendeeId,
+      method: options.method,
+      permissions: options.permissions
+    });
+  }
+  /**
+   * Resend invitations to pending participants
+   *
+   * @param token - Room token
+   * @param attendeeId - Optional specific attendee, or all if omitted
+   */
+  async resendInvitations(token, attendeeId) {
+    await this.http.post(`${BASE_PATH3}/${token}/participants/resend-invitations`, {
+      attendeeId
+    });
+  }
+};
+
+// src/types/constants.ts
+var ConversationType = /* @__PURE__ */ ((ConversationType2) => {
+  ConversationType2[ConversationType2["ONE_TO_ONE"] = 1] = "ONE_TO_ONE";
+  ConversationType2[ConversationType2["GROUP"] = 2] = "GROUP";
+  ConversationType2[ConversationType2["PUBLIC"] = 3] = "PUBLIC";
+  ConversationType2[ConversationType2["CHANGELOG"] = 4] = "CHANGELOG";
+  ConversationType2[ConversationType2["ONE_TO_ONE_FORMER"] = 5] = "ONE_TO_ONE_FORMER";
+  ConversationType2[ConversationType2["NOTE_TO_SELF"] = 6] = "NOTE_TO_SELF";
+  return ConversationType2;
+})(ConversationType || {});
+var ParticipantType = /* @__PURE__ */ ((ParticipantType2) => {
+  ParticipantType2[ParticipantType2["OWNER"] = 1] = "OWNER";
+  ParticipantType2[ParticipantType2["MODERATOR"] = 2] = "MODERATOR";
+  ParticipantType2[ParticipantType2["USER"] = 3] = "USER";
+  ParticipantType2[ParticipantType2["GUEST"] = 4] = "GUEST";
+  ParticipantType2[ParticipantType2["USER_SELF_JOINED"] = 5] = "USER_SELF_JOINED";
+  ParticipantType2[ParticipantType2["GUEST_MODERATOR"] = 6] = "GUEST_MODERATOR";
+  return ParticipantType2;
+})(ParticipantType || {});
+var Permission = /* @__PURE__ */ ((Permission2) => {
+  Permission2[Permission2["DEFAULT"] = 0] = "DEFAULT";
+  Permission2[Permission2["CUSTOM"] = 1] = "CUSTOM";
+  Permission2[Permission2["CALL_START"] = 2] = "CALL_START";
+  Permission2[Permission2["CALL_JOIN"] = 4] = "CALL_JOIN";
+  Permission2[Permission2["LOBBY_IGNORE"] = 8] = "LOBBY_IGNORE";
+  Permission2[Permission2["PUBLISH_AUDIO"] = 16] = "PUBLISH_AUDIO";
+  Permission2[Permission2["PUBLISH_VIDEO"] = 32] = "PUBLISH_VIDEO";
+  Permission2[Permission2["PUBLISH_SCREEN"] = 64] = "PUBLISH_SCREEN";
+  Permission2[Permission2["CHAT"] = 128] = "CHAT";
+  Permission2[Permission2["FILE_SHARE"] = 256] = "FILE_SHARE";
+  return Permission2;
+})(Permission || {});
+var InCallFlag = /* @__PURE__ */ ((InCallFlag2) => {
+  InCallFlag2[InCallFlag2["DISCONNECTED"] = 0] = "DISCONNECTED";
+  InCallFlag2[InCallFlag2["IN_CALL"] = 1] = "IN_CALL";
+  InCallFlag2[InCallFlag2["WITH_AUDIO"] = 2] = "WITH_AUDIO";
+  InCallFlag2[InCallFlag2["WITH_VIDEO"] = 4] = "WITH_VIDEO";
+  InCallFlag2[InCallFlag2["WITH_PHONE"] = 8] = "WITH_PHONE";
+  return InCallFlag2;
+})(InCallFlag || {});
+var ActorType = /* @__PURE__ */ ((ActorType2) => {
+  ActorType2["USERS"] = "users";
+  ActorType2["GUESTS"] = "guests";
+  ActorType2["EMAILS"] = "emails";
+  ActorType2["GROUPS"] = "groups";
+  ActorType2["CIRCLES"] = "circles";
+  ActorType2["BOTS"] = "bots";
+  ActorType2["BRIDGED"] = "bridged";
+  ActorType2["FEDERATED_USERS"] = "federated_users";
+  ActorType2["PHONES"] = "phones";
+  return ActorType2;
+})(ActorType || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["COMMENT"] = "comment";
+  MessageType2["SYSTEM"] = "system";
+  MessageType2["COMMAND"] = "command";
+  MessageType2["COMMENT_DELETED"] = "comment_deleted";
+  MessageType2["VOICE_MESSAGE"] = "voice-message";
+  MessageType2["RECORD_AUDIO"] = "record-audio";
+  MessageType2["RECORD_VIDEO"] = "record-video";
+  MessageType2["POLL"] = "poll";
+  return MessageType2;
+})(MessageType || {});
+var NotificationLevel = /* @__PURE__ */ ((NotificationLevel2) => {
+  NotificationLevel2[NotificationLevel2["DEFAULT"] = 0] = "DEFAULT";
+  NotificationLevel2[NotificationLevel2["ALWAYS"] = 1] = "ALWAYS";
+  NotificationLevel2[NotificationLevel2["MENTION"] = 2] = "MENTION";
+  NotificationLevel2[NotificationLevel2["NEVER"] = 3] = "NEVER";
+  return NotificationLevel2;
+})(NotificationLevel || {});
+var ReadOnlyState = /* @__PURE__ */ ((ReadOnlyState2) => {
+  ReadOnlyState2[ReadOnlyState2["READ_WRITE"] = 0] = "READ_WRITE";
+  ReadOnlyState2[ReadOnlyState2["READ_ONLY"] = 1] = "READ_ONLY";
+  return ReadOnlyState2;
+})(ReadOnlyState || {});
+var LobbyState = /* @__PURE__ */ ((LobbyState2) => {
+  LobbyState2[LobbyState2["DISABLED"] = 0] = "DISABLED";
+  LobbyState2[LobbyState2["ENABLED"] = 1] = "ENABLED";
+  return LobbyState2;
+})(LobbyState || {});
+var SIPState = /* @__PURE__ */ ((SIPState2) => {
+  SIPState2[SIPState2["DISABLED"] = 0] = "DISABLED";
+  SIPState2[SIPState2["ENABLED_NO_PIN"] = 1] = "ENABLED_NO_PIN";
+  SIPState2[SIPState2["ENABLED_WITH_PIN"] = 2] = "ENABLED_WITH_PIN";
+  return SIPState2;
+})(SIPState || {});
+var RecordingStatus = /* @__PURE__ */ ((RecordingStatus2) => {
+  RecordingStatus2[RecordingStatus2["NONE"] = 0] = "NONE";
+  RecordingStatus2[RecordingStatus2["VIDEO"] = 1] = "VIDEO";
+  RecordingStatus2[RecordingStatus2["AUDIO"] = 2] = "AUDIO";
+  RecordingStatus2[RecordingStatus2["STARTING_VIDEO"] = 3] = "STARTING_VIDEO";
+  RecordingStatus2[RecordingStatus2["STARTING_AUDIO"] = 4] = "STARTING_AUDIO";
+  RecordingStatus2[RecordingStatus2["FAILED"] = 5] = "FAILED";
+  return RecordingStatus2;
+})(RecordingStatus || {});
+var ListableScope = /* @__PURE__ */ ((ListableScope2) => {
+  ListableScope2[ListableScope2["NONE"] = 0] = "NONE";
+  ListableScope2[ListableScope2["USERS"] = 1] = "USERS";
+  ListableScope2[ListableScope2["EVERYONE"] = 2] = "EVERYONE";
+  return ListableScope2;
+})(ListableScope || {});
+var PollResultMode = /* @__PURE__ */ ((PollResultMode2) => {
+  PollResultMode2[PollResultMode2["PUBLIC"] = 0] = "PUBLIC";
+  PollResultMode2[PollResultMode2["HIDDEN"] = 1] = "HIDDEN";
+  return PollResultMode2;
+})(PollResultMode || {});
+var BreakoutRoomMode = /* @__PURE__ */ ((BreakoutRoomMode2) => {
+  BreakoutRoomMode2[BreakoutRoomMode2["NOT_CONFIGURED"] = 0] = "NOT_CONFIGURED";
+  BreakoutRoomMode2[BreakoutRoomMode2["AUTOMATIC"] = 1] = "AUTOMATIC";
+  BreakoutRoomMode2[BreakoutRoomMode2["MANUAL"] = 2] = "MANUAL";
+  BreakoutRoomMode2[BreakoutRoomMode2["FREE"] = 3] = "FREE";
+  return BreakoutRoomMode2;
+})(BreakoutRoomMode || {});
+var SharedObjectType = /* @__PURE__ */ ((SharedObjectType2) => {
+  SharedObjectType2["FILE"] = "file";
+  SharedObjectType2["AUDIO"] = "audio";
+  SharedObjectType2["VOICE"] = "voice";
+  SharedObjectType2["VIDEO"] = "video";
+  SharedObjectType2["LOCATION"] = "location";
+  SharedObjectType2["DECK_CARD"] = "deckcard";
+  SharedObjectType2["OTHER"] = "other";
+  SharedObjectType2["POLL"] = "poll";
+  SharedObjectType2["RECORDING"] = "recording";
+  return SharedObjectType2;
+})(SharedObjectType || {});
+
+// src/resources/call-resource.ts
+var CALL_PATH = "/ocs/v2.php/apps/spreed/api/v4/call";
+var SIGNALING_PATH = "/ocs/v2.php/apps/spreed/api/v3/signaling";
+var CallResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get peers currently in a call
+   *
+   * @param token - Room token
+   * @returns Array of call peers
+   */
+  async getPeers(token) {
+    const response = await this.http.get(`${CALL_PATH}/${token}`);
+    return response.data;
+  }
+  /**
+   * Join a call
+   *
+   * @param token - Room token
+   * @param options - Join options (flags, silent, etc.)
+   *
+   * @remarks
+   * Default flags are IN_CALL | WITH_AUDIO | WITH_VIDEO (7).
+   */
+  async join(token, options = {}) {
+    const flags = options.flags ?? 1 /* IN_CALL */ | 2 /* WITH_AUDIO */ | 4 /* WITH_VIDEO */;
+    await this.http.post(`${CALL_PATH}/${token}`, {
+      flags,
+      silent: options.silent,
+      recordingConsent: options.recordingConsent,
+      silentFor: options.silentFor
+    });
+  }
+  /**
+   * Update call flags (audio/video status)
+   *
+   * @param token - Room token
+   * @param flags - New in-call flags
+   */
+  async updateFlags(token, flags) {
+    await this.http.put(`${CALL_PATH}/${token}`, { flags });
+  }
+  /**
+   * Leave a call
+   *
+   * @param token - Room token
+   * @param options - Leave options
+   */
+  async leave(token, options = {}) {
+    await this.http.delete(`${CALL_PATH}/${token}`, { all: options.all });
+  }
+  /**
+   * Ring a specific attendee
+   *
+   * @param token - Room token
+   * @param attendeeId - Attendee ID to ring
+   *
+   * @remarks
+   * Requires START_CALL permission.
+   */
+  async ringAttendee(token, attendeeId) {
+    await this.http.post(`${CALL_PATH}/${token}/ring/${attendeeId}`);
+  }
+  /**
+   * Initiate SIP dial-out to a phone participant
+   *
+   * @param token - Room token
+   * @param attendeeId - Attendee ID to dial
+   */
+  async dialOut(token, attendeeId) {
+    await this.http.post(`${CALL_PATH}/${token}/dialout/${attendeeId}`);
+  }
+  /**
+   * Get signaling settings for WebRTC
+   *
+   * @param token - Room token
+   * @returns Signaling configuration including STUN/TURN servers
+   */
+  async getSignalingSettings(token) {
+    const response = await this.http.get(
+      `${SIGNALING_PATH}/settings`,
+      { token }
+    );
+    return response.data;
+  }
+  // Convenience methods for common flag operations
+  /**
+   * Enable audio in call
+   *
+   * @param token - Room token
+   * @param currentFlags - Current in-call flags
+   */
+  async enableAudio(token, currentFlags) {
+    await this.updateFlags(token, currentFlags | 2 /* WITH_AUDIO */);
+  }
+  /**
+   * Disable audio in call
+   *
+   * @param token - Room token
+   * @param currentFlags - Current in-call flags
+   */
+  async disableAudio(token, currentFlags) {
+    await this.updateFlags(token, currentFlags & ~2 /* WITH_AUDIO */);
+  }
+  /**
+   * Enable video in call
+   *
+   * @param token - Room token
+   * @param currentFlags - Current in-call flags
+   */
+  async enableVideo(token, currentFlags) {
+    await this.updateFlags(token, currentFlags | 4 /* WITH_VIDEO */);
+  }
+  /**
+   * Disable video in call
+   *
+   * @param token - Room token
+   * @param currentFlags - Current in-call flags
+   */
+  async disableVideo(token, currentFlags) {
+    await this.updateFlags(token, currentFlags & ~4 /* WITH_VIDEO */);
+  }
+};
+
+// src/resources/poll-resource.ts
+var BASE_PATH4 = "/ocs/v2.php/apps/spreed/api/v1/poll";
+var PollResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new poll
+   *
+   * @param token - Room token
+   * @param options - Poll creation options
+   * @returns Created poll
+   */
+  async create(token, options) {
+    const response = await this.http.post(`${BASE_PATH4}/${token}`, {
+      question: options.question,
+      options: options.options,
+      resultMode: options.resultMode ?? 0,
+      maxVotes: options.maxVotes ?? 1,
+      draft: options.draft,
+      threadId: options.threadId
+    });
+    return response.data;
+  }
+  /**
+   * Get a poll by ID
+   *
+   * @param token - Room token
+   * @param pollId - Poll ID
+   * @returns Poll data
+   */
+  async get(token, pollId) {
+    const response = await this.http.get(`${BASE_PATH4}/${token}/${pollId}`);
+    return response.data;
+  }
+  /**
+   * Vote on a poll
+   *
+   * @param token - Room token
+   * @param pollId - Poll ID
+   * @param options - Vote options (option indices)
+   * @returns Updated poll
+   */
+  async vote(token, pollId, options) {
+    const response = await this.http.post(`${BASE_PATH4}/${token}/${pollId}`, {
+      optionIds: options.optionIds
+    });
+    return response.data;
+  }
+  /**
+   * Close or delete a poll
+   *
+   * @param token - Room token
+   * @param pollId - Poll ID
+   * @returns Closed poll
+   */
+  async close(token, pollId) {
+    const response = await this.http.delete(`${BASE_PATH4}/${token}/${pollId}`);
+    return response.data;
+  }
+  /**
+   * Get poll drafts
+   *
+   * @param token - Room token
+   * @returns Array of draft polls
+   */
+  async getDrafts(token) {
+    const response = await this.http.get(`${BASE_PATH4}/${token}/drafts`);
+    return response.data;
+  }
+  /**
+   * Update a poll draft
+   *
+   * @param token - Room token
+   * @param pollId - Poll draft ID
+   * @param options - Updated poll options
+   * @returns Updated draft
+   */
+  async updateDraft(token, pollId, options) {
+    const response = await this.http.post(`${BASE_PATH4}/${token}/draft/${pollId}`, {
+      question: options.question,
+      options: options.options,
+      resultMode: options.resultMode,
+      maxVotes: options.maxVotes
+    });
+    return response.data;
+  }
+};
+
+// src/resources/reaction-resource.ts
+var BASE_PATH5 = "/ocs/v2.php/apps/spreed/api/v1/reaction";
+var ReactionResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Add a reaction to a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID
+   * @param reaction - Emoji reaction (e.g., "👍")
+   * @returns Updated reactions map
+   */
+  async add(token, messageId, reaction) {
+    const response = await this.http.post(
+      `${BASE_PATH5}/${token}/${messageId}`,
+      { reaction }
+    );
+    return response.data;
+  }
+  /**
+   * Remove a reaction from a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID
+   * @param reaction - Emoji reaction to remove
+   * @returns Updated reactions map
+   */
+  async remove(token, messageId, reaction) {
+    const response = await this.http.delete(
+      `${BASE_PATH5}/${token}/${messageId}`,
+      { reaction }
+    );
+    return response.data;
+  }
+  /**
+   * Get reactions for a message
+   *
+   * @param token - Room token
+   * @param messageId - Message ID
+   * @param reaction - Optional specific emoji to filter
+   * @returns Reactions grouped by emoji
+   */
+  async get(token, messageId, reaction) {
+    const response = await this.http.get(
+      `${BASE_PATH5}/${token}/${messageId}`,
+      { reaction }
+    );
+    return response.data;
+  }
+};
+
+// src/domain/room.ts
+var Room = class {
+  /** Room token - primary API identifier */
+  token;
+  /** Room internal database ID */
+  id;
+  /** Conversation type */
+  type;
+  /** Room name */
+  name;
+  /** Computed display name */
+  displayName;
+  /** Room description */
+  description;
+  /** Current user's participant type/role */
+  participantType;
+  /** Current user's effective permissions */
+  permissions;
+  /** Whether room has a password */
+  hasPassword;
+  /** Whether there's an active call */
+  hasCall;
+  /** Read-only state */
+  readOnly;
+  /** Lobby state */
+  lobbyState;
+  /** Number of unread messages */
+  unreadMessages;
+  /** Whether there are unread mentions */
+  unreadMention;
+  /** Whether this is a favorite room */
+  isFavorite;
+  /** Whether this room is archived */
+  isArchived;
+  /** Last activity timestamp */
+  lastActivity;
+  /** Raw normalized data for advanced access */
+  _data;
+  resources;
+  constructor(data, resources) {
+    this._data = data;
+    this.resources = resources;
+    this.token = data.token;
+    this.id = data.id;
+    this.type = data.type;
+    this.name = data.name;
+    this.displayName = data.displayName;
+    this.description = data.description;
+    this.participantType = data.participantType;
+    this.permissions = data.permissions;
+    this.hasPassword = data.hasPassword;
+    this.hasCall = data.hasCall;
+    this.readOnly = data.readOnly;
+    this.lobbyState = data.lobbyState;
+    this.unreadMessages = data.unreadMessages;
+    this.unreadMention = data.unreadMention;
+    this.lastActivity = data.lastActivity;
+    this.isFavorite = data.isFavorite;
+    this.isArchived = data.isArchived;
+  }
+  // ==================== Chat Operations ====================
+  /**
+   * Send a message to this room
+   *
+   * @param message - Message content or full options
+   * @returns Sent message
+   */
+  async sendMessage(message) {
+    const options = typeof message === "string" ? { message } : message;
+    return this.resources.chat.sendMessage(this.token, options);
+  }
+  /**
+   * Get message history
+   *
+   * @param options - Optional limit and pagination
+   * @returns Array of messages
+   */
+  async getHistory(options = {}) {
+    return this.resources.chat.getHistory(this.token, options);
+  }
+  /**
+   * Poll for new messages (long-polling)
+   *
+   * @param options - Poll options with lastKnownMessageId
+   * @returns Poll result with messages and metadata
+   */
+  async pollMessages(options) {
+    return this.resources.chat.pollMessages(this.token, options);
+  }
+  /**
+   * Edit a message
+   *
+   * @param messageId - Message ID to edit
+   * @param newContent - New message content
+   * @returns Updated message
+   */
+  async editMessage(messageId, newContent) {
+    return this.resources.chat.editMessage(this.token, messageId, newContent);
+  }
+  /**
+   * Delete a message
+   *
+   * @param messageId - Message ID to delete
+   * @returns Deleted message placeholder
+   */
+  async deleteMessage(messageId) {
+    return this.resources.chat.deleteMessage(this.token, messageId);
+  }
+  /**
+   * Set the read marker
+   *
+   * @param lastReadMessage - Message ID to mark as last read
+   */
+  async setReadMarker(lastReadMessage) {
+    return this.resources.chat.setReadMarker(this.token, lastReadMessage);
+  }
+  // ==================== Participant Operations ====================
+  /**
+   * Get participants in this room
+   *
+   * @param includeStatus - Include user status information
+   * @returns Array of participants
+   */
+  async getParticipants(includeStatus = false) {
+    return this.resources.participants.list(this.token, includeStatus);
+  }
+  /**
+   * Add a user to this room
+   *
+   * @param userId - User ID to add
+   * @param source - Source type (default: 'users')
+   */
+  async addParticipant(userId, source = "users") {
+    return this.resources.participants.add(this.token, {
+      newParticipant: userId,
+      source
+    });
+  }
+  /**
+   * Remove a participant from this room
+   *
+   * @param attendeeId - Attendee ID to remove
+   */
+  async removeParticipant(attendeeId) {
+    return this.resources.participants.remove(this.token, attendeeId);
+  }
+  /**
+   * Leave this room
+   */
+  async leave() {
+    return this.resources.participants.removeSelf(this.token);
+  }
+  // ==================== Call Operations ====================
+  /**
+   * Get peers currently in the call
+   *
+   * @returns Array of call peers
+   */
+  async getCallPeers() {
+    return this.resources.call.getPeers(this.token);
+  }
+  /**
+   * Join the call
+   *
+   * @param options - Join options (flags, silent, etc.)
+   */
+  async joinCall(options = {}) {
+    return this.resources.call.join(this.token, options);
+  }
+  /**
+   * Leave the call
+   *
+   * @param endForAll - End call for everyone (moderator only)
+   */
+  async leaveCall(endForAll = false) {
+    return this.resources.call.leave(this.token, { all: endForAll });
+  }
+  // ==================== Poll Operations ====================
+  /**
+   * Create a poll in this room
+   *
+   * @param options - Poll creation options
+   * @returns Created poll
+   */
+  async createPoll(options) {
+    return this.resources.poll.create(this.token, options);
+  }
+  // ==================== Reaction Operations ====================
+  /**
+   * Add a reaction to a message
+   *
+   * @param messageId - Message ID
+   * @param reaction - Emoji reaction
+   */
+  async addReaction(messageId, reaction) {
+    await this.resources.reaction.add(this.token, messageId, reaction);
+  }
+  /**
+   * Remove a reaction from a message
+   *
+   * @param messageId - Message ID
+   * @param reaction - Emoji reaction to remove
+   */
+  async removeReaction(messageId, reaction) {
+    await this.resources.reaction.remove(this.token, messageId, reaction);
+  }
+  // ==================== Computed Properties ====================
+  /** Whether the current user is a moderator or owner */
+  get isModerator() {
+    return this.participantType === 1 /* OWNER */ || this.participantType === 2 /* MODERATOR */ || this.participantType === 6 /* GUEST_MODERATOR */;
+  }
+  /** Whether this is a one-to-one conversation */
+  get isOneToOne() {
+    return this.type === 1 /* ONE_TO_ONE */;
+  }
+  /** Whether this is a group conversation */
+  get isGroup() {
+    return this.type === 2 /* GROUP */;
+  }
+  /** Whether this is a public (open) conversation */
+  get isPublic() {
+    return this.type === 3 /* PUBLIC */;
+  }
+  /** Whether the room is currently read-only */
+  get isReadOnly() {
+    return this.readOnly === 1 /* READ_ONLY */;
+  }
+  /** Whether the lobby is enabled */
+  get hasLobby() {
+    return this.lobbyState === 1 /* ENABLED */;
+  }
+};
+
+// src/client.ts
+var RoomsAccessor = class {
+  constructor(roomResource, roomResources) {
+    this.roomResource = roomResource;
+    this.roomResources = roomResources;
+  }
+  /**
+   * List all conversations the current user is part of
+   *
+   * @param options - List options
+   * @returns Array of Room entities
+   *
+   * @example
+   * ```ts
+   * const rooms = await client.rooms.list();
+   * const targetRoom = rooms.find(r => r.token === 'abcdefgh');
+   * ```
+   */
+  async list(options = {}) {
+    const normalized = await this.roomResource.list(options);
+    return normalized.map((data) => new Room(data, this.roomResources));
+  }
+  /**
+   * Get a single room by token
+   *
+   * @param token - Room token
+   * @returns Room entity
+   */
+  async get(token) {
+    const normalized = await this.roomResource.get(token);
+    return new Room(normalized, this.roomResources);
+  }
+  /**
+   * Create a new room
+   *
+   * @param options - Room creation options
+   * @returns Created Room entity
+   *
+   * @example
+   * ```ts
+   * // Create a group room
+   * const room = await client.rooms.create({
+   *   roomType: 2,
+   *   roomName: 'Team Chat',
+   * });
+   *
+   * // Create a 1-1 chat
+   * const dm = await client.rooms.create({
+   *   roomType: 1,
+   *   invite: 'other-user',
+   *   source: 'users',
+   * });
+   * ```
+   */
+  async create(options) {
+    const normalized = await this.roomResource.create(options);
+    return new Room(normalized, this.roomResources);
+  }
+  /**
+   * Delete a room
+   *
+   * @param token - Room token
+   */
+  async delete(token) {
+    await this.roomResource.delete(token);
+  }
+  /**
+   * Rename a room
+   *
+   * @param token - Room token
+   * @param name - New room name
+   */
+  async rename(token, name) {
+    await this.roomResource.rename(token, name);
+  }
+};
+var TalkClient = class {
+  /** HTTP client for direct API access */
+  http;
+  /** Rooms accessor for room operations */
+  rooms;
+  /** Direct access to chat resource */
+  chat;
+  /** Direct access to participant resource */
+  participants;
+  /** Direct access to call resource */
+  call;
+  /** Direct access to poll resource */
+  poll;
+  /** Direct access to reaction resource */
+  reaction;
+  /** Direct access to room resource */
+  roomResource;
+  constructor(config) {
+    this.http = new HttpClient({
+      host: config.host,
+      username: config.username,
+      password: config.password,
+      fetch: config.fetch
+    });
+    this.roomResource = new RoomResource(this.http);
+    this.chat = new ChatResource(this.http);
+    this.participants = new ParticipantResource(this.http);
+    this.call = new CallResource(this.http);
+    this.poll = new PollResource(this.http);
+    this.reaction = new ReactionResource(this.http);
+    const roomResources = {
+      chat: this.chat,
+      participants: this.participants,
+      call: this.call,
+      poll: this.poll,
+      reaction: this.reaction
+    };
+    this.rooms = new RoomsAccessor(this.roomResource, roomResources);
+  }
+  /**
+   * Get the base URL for this client
+   */
+  get host() {
+    return this.http.host;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActorType,
+  BreakoutRoomMode,
+  CallResource,
+  ChatResource,
+  ConversationType,
+  HttpClient,
+  HttpClientError,
+  InCallFlag,
+  ListableScope,
+  LobbyState,
+  MessageType,
+  NotificationLevel,
+  ParticipantResource,
+  ParticipantType,
+  Permission,
+  PollResource,
+  PollResultMode,
+  ReactionResource,
+  ReadOnlyState,
+  RecordingStatus,
+  Room,
+  RoomResource,
+  RoomsAccessor,
+  SIPState,
+  SharedObjectType,
+  TalkClient,
+  normalizeMessage,
+  normalizeMessageWithParent,
+  normalizeMessages,
+  normalizeParticipant,
+  normalizeParticipants,
+  normalizeRoom,
+  normalizeRooms
+});