@noematicsllc/talk-sdk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,2147 @@
+/**
+ * Transport Layer - HTTP Client for Nextcloud Talk API
+ *
+ * Handles all HTTP communication with the Nextcloud OCS API,
+ * automatically injecting required headers and managing authentication.
+ */
+/** Configuration options for the HTTP client */
+interface HttpClientConfig {
+    /** Nextcloud server host URL (e.g., 'https://nextcloud.local') */
+    host: string;
+    /** Nextcloud username for authentication */
+    username: string;
+    /** App password or regular password for authentication */
+    password: string;
+    /** Optional custom fetch implementation (for testing or Node.js compatibility) */
+    fetch?: typeof fetch;
+}
+/** Standard OCS API response envelope */
+interface OCSResponse<T> {
+    ocs: {
+        meta: {
+            status: string;
+            statuscode: number;
+            message: string;
+        };
+        data: T;
+    };
+}
+/** HTTP request options */
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    body?: unknown;
+    params?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    /** Timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/** Response metadata from Nextcloud headers */
+interface ResponseMeta {
+    /** Hash for cache invalidation */
+    talkHash?: string;
+    /** Timestamp for delta sync */
+    modifiedBefore?: number;
+    /** Last message ID in chat response */
+    chatLastGiven?: number;
+    /** Last common read message ID */
+    chatLastCommonRead?: number;
+    /** Pending federation invites count */
+    federationInvites?: number;
+}
+/** Extended response with data and metadata */
+interface HttpResponse<T> {
+    data: T;
+    status: number;
+    meta: ResponseMeta;
+    headers: Headers;
+}
+/** HTTP client error with status code and OCS details */
+declare class HttpClientError extends Error {
+    readonly status: number;
+    readonly ocsStatus?: number | undefined;
+    readonly ocsMessage?: string | undefined;
+    constructor(message: string, status: number, ocsStatus?: number | undefined, ocsMessage?: string | undefined);
+}
+/**
+ * Base HTTP client for Nextcloud OCS API
+ *
+ * Automatically injects required OCS headers:
+ * - OCS-APIRequest: true
+ * - Accept: application/json
+ * - Content-Type: application/json
+ * - Authorization: Basic (base64 encoded credentials)
+ */
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly authHeader;
+    private readonly fetchImpl;
+    constructor(config: HttpClientConfig);
+    /**
+     * Build the full URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Extract Nextcloud-specific headers from response
+     */
+    private extractMeta;
+    /**
+     * 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
+     */
+    request<T>(path: string, options?: RequestOptions): Promise<HttpResponse<T>>;
+    /** GET request helper */
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<HttpResponse<T>>;
+    /** POST request helper */
+    post<T>(path: string, body?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<HttpResponse<T>>;
+    /** PUT request helper */
+    put<T>(path: string, body?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<HttpResponse<T>>;
+    /** DELETE request helper */
+    delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<HttpResponse<T>>;
+    /** Get the base URL for this client */
+    get host(): string;
+}
+
+/**
+ * Nextcloud Talk API Constants
+ *
+ * Enum values and constants used throughout the API.
+ */
+/** Conversation/Room types */
+declare enum ConversationType {
+    /** One-to-one private conversation */
+    ONE_TO_ONE = 1,
+    /** Group conversation (invite only) */
+    GROUP = 2,
+    /** Public conversation (anyone with link can join) */
+    PUBLIC = 3,
+    /** Changelog (system notifications) */
+    CHANGELOG = 4,
+    /** Former one-to-one (user deleted) */
+    ONE_TO_ONE_FORMER = 5,
+    /** Note to self (personal notes) */
+    NOTE_TO_SELF = 6
+}
+/** Participant role types */
+declare enum ParticipantType {
+    /** Room owner with full permissions */
+    OWNER = 1,
+    /** Moderator with elevated permissions */
+    MODERATOR = 2,
+    /** Regular user participant */
+    USER = 3,
+    /** Guest participant (no Nextcloud account) */
+    GUEST = 4,
+    /** User who self-joined a public room */
+    USER_SELF_JOINED = 5,
+    /** Guest with moderator permissions */
+    GUEST_MODERATOR = 6
+}
+/** Permission flags (bitmask) */
+declare enum Permission {
+    /** Inherit default permissions */
+    DEFAULT = 0,
+    /** Custom permissions set */
+    CUSTOM = 1,
+    /** Can start a call */
+    CALL_START = 2,
+    /** Can join a call */
+    CALL_JOIN = 4,
+    /** Can bypass lobby */
+    LOBBY_IGNORE = 8,
+    /** Can send audio */
+    PUBLISH_AUDIO = 16,
+    /** Can send video */
+    PUBLISH_VIDEO = 32,
+    /** Can share screen */
+    PUBLISH_SCREEN = 64,
+    /** Can post chat messages */
+    CHAT = 128,
+    /** Can share files */
+    FILE_SHARE = 256
+}
+/** In-call status flags (bitmask) */
+declare enum InCallFlag {
+    /** Not in call */
+    DISCONNECTED = 0,
+    /** Currently in call */
+    IN_CALL = 1,
+    /** Audio enabled */
+    WITH_AUDIO = 2,
+    /** Video enabled */
+    WITH_VIDEO = 4,
+    /** Connected via phone/SIP */
+    WITH_PHONE = 8
+}
+/** Actor types for participants and message authors */
+declare enum ActorType {
+    /** Nextcloud users */
+    USERS = "users",
+    /** Guest users */
+    GUESTS = "guests",
+    /** Email invitees */
+    EMAILS = "emails",
+    /** User groups */
+    GROUPS = "groups",
+    /** Nextcloud circles */
+    CIRCLES = "circles",
+    /** Bot accounts */
+    BOTS = "bots",
+    /** Matterbridge users */
+    BRIDGED = "bridged",
+    /** Federated users from other instances */
+    FEDERATED_USERS = "federated_users",
+    /** Phone participants (SIP) */
+    PHONES = "phones"
+}
+/** Chat message types */
+declare enum MessageType {
+    /** Regular text message */
+    COMMENT = "comment",
+    /** System-generated message */
+    SYSTEM = "system",
+    /** Command message */
+    COMMAND = "command",
+    /** Deleted message placeholder */
+    COMMENT_DELETED = "comment_deleted",
+    /** Voice recording message */
+    VOICE_MESSAGE = "voice-message",
+    /** Audio recording */
+    RECORD_AUDIO = "record-audio",
+    /** Video recording */
+    RECORD_VIDEO = "record-video",
+    /** Poll message */
+    POLL = "poll"
+}
+/** Notification level settings */
+declare enum NotificationLevel {
+    /** Use default notification settings */
+    DEFAULT = 0,
+    /** Always notify */
+    ALWAYS = 1,
+    /** Only notify on mentions */
+    MENTION = 2,
+    /** Never notify */
+    NEVER = 3
+}
+/** Read-only state */
+declare enum ReadOnlyState {
+    /** Room is read-write */
+    READ_WRITE = 0,
+    /** Room is read-only */
+    READ_ONLY = 1
+}
+/** Lobby state */
+declare enum LobbyState {
+    /** No lobby */
+    DISABLED = 0,
+    /** Lobby enabled for non-moderators */
+    ENABLED = 1
+}
+/** SIP state */
+declare enum SIPState {
+    /** SIP disabled */
+    DISABLED = 0,
+    /** SIP enabled without PIN */
+    ENABLED_NO_PIN = 1,
+    /** SIP enabled with PIN */
+    ENABLED_WITH_PIN = 2
+}
+/** Recording status */
+declare enum RecordingStatus {
+    /** Not recording */
+    NONE = 0,
+    /** Recording video */
+    VIDEO = 1,
+    /** Recording audio only */
+    AUDIO = 2,
+    /** Starting video recording */
+    STARTING_VIDEO = 3,
+    /** Starting audio recording */
+    STARTING_AUDIO = 4,
+    /** Recording failed */
+    FAILED = 5
+}
+/** Listable scope */
+declare enum ListableScope {
+    /** Not listable */
+    NONE = 0,
+    /** Listable for logged-in users */
+    USERS = 1,
+    /** Listable for everyone */
+    EVERYONE = 2
+}
+/** Poll result mode */
+declare enum PollResultMode {
+    /** Results are public */
+    PUBLIC = 0,
+    /** Results are hidden until closed */
+    HIDDEN = 1
+}
+/** Breakout room mode */
+declare enum BreakoutRoomMode {
+    /** Not configured */
+    NOT_CONFIGURED = 0,
+    /** Automatic assignment */
+    AUTOMATIC = 1,
+    /** Manual assignment */
+    MANUAL = 2,
+    /** Free selection */
+    FREE = 3
+}
+/** Object types for shared items */
+declare enum SharedObjectType {
+    FILE = "file",
+    AUDIO = "audio",
+    VOICE = "voice",
+    VIDEO = "video",
+    LOCATION = "location",
+    DECK_CARD = "deckcard",
+    OTHER = "other",
+    POLL = "poll",
+    RECORDING = "recording"
+}
+
+/**
+ * Message Types
+ *
+ * TypeScript interfaces for Nextcloud Talk chat message entities.
+ */
+/** Rich object parameter in message */
+interface TalkRichObjectParameter {
+    type: string;
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+/** Message metadata for pinned messages */
+interface MessageMetadata {
+    pinnedActorType?: string;
+    pinnedActorId?: string;
+    pinnedActorDisplayName?: string;
+    pinnedAt?: number;
+    pinnedUntil?: number;
+}
+/** Deleted message reference */
+interface DeletedMessageRef {
+    id: number;
+    deleted: true;
+}
+/**
+ * Chat message as returned by the Nextcloud Talk API
+ */
+interface TalkChatMessage {
+    /** Message ID */
+    id: number;
+    /** Room token this message belongs to */
+    token: string;
+    /** Actor type of the sender */
+    actorType: string;
+    /** Actor ID of the sender */
+    actorId: string;
+    /** Display name of the sender */
+    actorDisplayName: string;
+    /** Unix timestamp when message was sent */
+    timestamp: number;
+    /** Message content */
+    message: string;
+    /** Message type (comment, system, etc.) */
+    messageType: string;
+    /** System message type (empty for regular messages) */
+    systemMessage: string;
+    /** Rich object parameters for mentions, files, etc. */
+    messageParameters: Record<string, TalkRichObjectParameter>;
+    /** Whether the message can be replied to */
+    isReplyable: boolean;
+    /** Whether the message supports markdown */
+    markdown: boolean;
+    /** Client-generated reference ID for deduplication */
+    referenceId: string;
+    /** Unix timestamp when message expires (0 = never) */
+    expirationTimestamp: number;
+    /** Map of reaction emoji to count */
+    reactions: Record<string, number>;
+    /** Reactions by the current user */
+    reactionsSelf?: string[];
+    /** Actor type of last editor */
+    lastEditActorType?: string;
+    /** Actor ID of last editor */
+    lastEditActorId?: string;
+    /** Display name of last editor */
+    lastEditActorDisplayName?: string;
+    /** Unix timestamp of last edit */
+    lastEditTimestamp?: number;
+    /** Thread ID if part of a thread */
+    threadId?: number;
+    /** Whether this message is a thread root */
+    isThread?: boolean;
+    /** Thread title */
+    threadTitle?: string;
+    /** Number of replies in thread */
+    threadReplies?: number;
+    /** Additional metadata (pinning info, etc.) */
+    metaData?: MessageMetadata;
+}
+/** Message with optional parent for reply context */
+interface TalkChatMessageWithParent extends TalkChatMessage {
+    /** Parent message for replies */
+    parent?: TalkChatMessage | DeletedMessageRef;
+}
+/** Options for sending a message */
+interface SendMessageOptions {
+    /** Message content (max 32000 chars) */
+    message: string;
+    /** Display name for guests */
+    actorDisplayName?: string;
+    /** Client-generated ID for deduplication */
+    referenceId?: string;
+    /** Parent message ID for replies */
+    replyTo?: number;
+    /** Don't trigger notifications */
+    silent?: boolean;
+    /** Thread ID */
+    threadId?: number;
+    /** Thread title (creates new thread) */
+    threadTitle?: string;
+}
+/** Options for receiving messages */
+interface ReceiveMessagesOptions {
+    /** 0 = history, 1 = new messages (polling) */
+    lookIntoFuture: 0 | 1;
+    /** Max messages to return (default 100, max 200) */
+    limit?: number;
+    /** Pagination cursor - get messages after this ID */
+    lastKnownMessageId?: number;
+    /** Long-poll timeout in seconds (max 60) */
+    timeout?: number;
+    /** Auto-update read marker */
+    setReadMarker?: boolean;
+    /** Include boundary message */
+    includeLastKnown?: boolean;
+    /** Clear notifications */
+    markNotificationsAsRead?: boolean;
+    /** Filter by thread */
+    threadId?: number;
+}
+/** Options for polling new messages */
+interface PollMessagesOptions {
+    /** Last known message ID to poll from */
+    lastKnownMessageId: number;
+    /** Max messages to return */
+    limit?: number;
+    /** Long-poll timeout in seconds (default 30) */
+    timeout?: number;
+    /** Filter by thread */
+    threadId?: number;
+}
+/** Mention suggestion from search */
+interface TalkChatMentionSuggestion {
+    id: string;
+    label: string;
+    source: string;
+    mentionId?: string;
+    status?: string;
+    statusIcon?: string;
+    statusMessage?: string;
+}
+/** Options for sharing a rich object */
+interface ShareObjectOptions {
+    objectType: string;
+    objectId: string;
+    metaData?: string;
+    referenceId?: string;
+    threadId?: number;
+}
+/** Reminder for a message */
+interface MessageReminder {
+    messageId: number;
+    timestamp: number;
+    token: string;
+    userId: string;
+}
+/** Options for scheduling a message */
+interface ScheduleMessageOptions {
+    message: string;
+    scheduledAt: number;
+    referenceId?: string;
+    replyTo?: number;
+    silent?: boolean;
+}
+/** Result of chat polling with metadata */
+interface ChatPollResult {
+    messages: TalkChatMessageWithParent[];
+    /** Last message ID for next poll */
+    lastKnownMessageId?: number;
+    /** Last message read by all participants */
+    lastCommonRead?: number;
+}
+
+/**
+ * Room/Conversation Types
+ *
+ * TypeScript interfaces for Nextcloud Talk room/conversation entities.
+ */
+
+/**
+ * Raw room data as returned by the Nextcloud Talk API
+ *
+ * @remarks
+ * This interface matches the TalkRoom type from the API specification.
+ * Use the Room class from the domain layer for a higher-level abstraction.
+ */
+interface TalkRoom {
+    /** Internal database ID (rarely used in API calls) */
+    id: number;
+    /** API identifier - use this for all API calls */
+    token: string;
+    /** Conversation type (1-6) */
+    type: number;
+    /** Room name */
+    name: string;
+    /** Computed display name */
+    displayName: string;
+    /** Room description (max 2000 chars) */
+    description: string;
+    /** Actor type of the current user */
+    actorType: string;
+    /** Actor ID of the current user */
+    actorId: string;
+    /** Attendee ID of the current user in this room */
+    attendeeId: number;
+    /** Participant type/role of the current user */
+    participantType: number;
+    /** Effective permissions (computed) */
+    permissions: number;
+    /** Dedicated attendee permissions */
+    attendeePermissions: number;
+    /** Whether the room has a password */
+    hasPassword: boolean;
+    /** Whether there's an active call */
+    hasCall: boolean;
+    /** Combined participant call flags */
+    callFlag: number;
+    /** Unix timestamp when call started */
+    callStartTime: number;
+    /** Current recording status */
+    callRecording: number;
+    /** Read-only state (0 = read-write, 1 = read-only) */
+    readOnly: number;
+    /** Listable scope */
+    listable: number;
+    /** Lobby state */
+    lobbyState: number;
+    /** Lobby timer (Unix timestamp) */
+    lobbyTimer: number;
+    /** SIP enabled state */
+    sipEnabled: number;
+    /** Mention permissions */
+    mentionPermissions: number;
+    /** Message expiration in seconds (0 = never) */
+    messageExpiration: number;
+    /** Recording consent requirement */
+    recordingConsent: number;
+    /** Last activity timestamp */
+    lastActivity: number;
+    /** Last message in the room (optional) */
+    lastMessage?: TalkChatMessage;
+    /** ID of last read message */
+    lastReadMessage: number;
+    /** ID of last message read by all participants */
+    lastCommonReadMessage: number;
+    /** Number of unread messages */
+    unreadMessages: number;
+    /** Whether there are unread mentions */
+    unreadMention: boolean;
+    /** Whether there are direct unread mentions */
+    unreadMentionDirect: boolean;
+    /** Whether current user can start a call */
+    canStartCall: boolean;
+    /** Whether current user can leave the conversation */
+    canLeaveConversation: boolean;
+    /** Whether current user can delete the conversation */
+    canDeleteConversation: boolean;
+    /** Whether SIP can be enabled */
+    canEnableSIP: boolean;
+    /** User status string */
+    status?: string;
+    /** User status icon */
+    statusIcon?: string;
+    /** User status message */
+    statusMessage?: string;
+    /** Unix timestamp when status clears */
+    statusClearAt?: number;
+    /** Remote server URL for federated rooms */
+    remoteServer?: string;
+    /** Remote token for federated rooms */
+    remoteToken?: string;
+    /** Whether this room is a favorite */
+    isFavorite: boolean;
+    /** Whether this room is archived */
+    isArchived: boolean;
+    /** Whether this room is marked important */
+    isImportant: boolean;
+    /** Whether this room is marked sensitive */
+    isSensitive: boolean;
+}
+/** Options for creating a new room */
+interface CreateRoomOptions {
+    /** Room type (1-6) */
+    roomType: number;
+    /** Room name */
+    roomName?: string;
+    /** User/entity to invite */
+    invite?: string;
+    /** Source of the invite (users, groups, etc.) */
+    source?: string;
+    /** Object type for linked rooms */
+    objectType?: string;
+    /** Object ID for linked rooms */
+    objectId?: string;
+    /** Room password */
+    password?: string;
+    /** Read-only state */
+    readOnly?: number;
+    /** Listable scope */
+    listable?: number;
+    /** Message expiration in seconds */
+    messageExpiration?: number;
+    /** Lobby state */
+    lobbyState?: number;
+    /** Lobby timer (Unix timestamp) */
+    lobbyTimer?: number;
+    /** SIP enabled state */
+    sipEnabled?: number;
+    /** Default permissions */
+    permissions?: number;
+    /** Recording consent requirement */
+    recordingConsent?: number;
+    /** Mention permissions */
+    mentionPermissions?: number;
+    /** Room description */
+    description?: string;
+}
+/** Options for listing rooms */
+interface ListRoomsOptions {
+    /** Don't update user online status */
+    noStatusUpdate?: boolean;
+    /** Include user status for 1-1 chats */
+    includeStatus?: boolean;
+    /** Unix timestamp for delta sync */
+    modifiedSince?: number;
+    /** Include last message in response */
+    includeLastMessage?: boolean;
+}
+/** Notification level setting */
+interface NotificationSettings {
+    level: number;
+}
+/** Call notification setting */
+interface CallNotificationSettings {
+    level: number;
+}
+/** Lobby settings */
+interface LobbySettings {
+    state: number;
+    timer?: number;
+}
+/** Permission update modes */
+type PermissionMode = 'default' | 'call';
+
+/**
+ * Participant Types
+ *
+ * TypeScript interfaces for Nextcloud Talk participant entities.
+ */
+/**
+ * Participant in a room as returned by the API
+ */
+interface TalkParticipant {
+    /** Actor type (users, guests, etc.) */
+    actorType: string;
+    /** Actor ID */
+    actorId: string;
+    /** Display name */
+    displayName: string;
+    /** Attendee ID in this room */
+    attendeeId: number;
+    /** Participant type/role */
+    participantType: number;
+    /** Effective permissions */
+    permissions: number;
+    /** Dedicated attendee permissions */
+    attendeePermissions: number;
+    /** Attendee PIN for SIP */
+    attendeePin: string;
+    /** Room token */
+    roomToken: string;
+    /** Active session IDs */
+    sessionIds: string[];
+    /** In-call status flags */
+    inCall: number;
+    /** Last ping timestamp */
+    lastPing: number;
+    /** User status string */
+    status?: string;
+    /** User status icon */
+    statusIcon?: string;
+    /** User status message */
+    statusMessage?: string;
+    /** Unix timestamp when status clears */
+    statusClearAt?: number;
+    /** Phone number for phone participants */
+    phoneNumber?: string;
+    /** Call ID for phone participants */
+    callId?: string;
+}
+/** Options for adding a participant */
+interface AddParticipantOptions {
+    /** User ID or identifier to add */
+    newParticipant: string;
+    /** Source of the participant */
+    source: 'users' | 'groups' | 'circles' | 'emails' | 'federated_users' | 'phones' | 'teams';
+}
+/** Options for joining a room */
+interface JoinRoomOptions {
+    /** Room password if required */
+    password?: string;
+    /** Force join even if already in room on another device */
+    force?: boolean;
+}
+/** Session conflict response when joining */
+interface SessionConflict {
+    sessionId: string;
+    inCall: number;
+    lastPing: number;
+}
+/** Permission update method */
+type PermissionMethod = 'set' | 'add' | 'remove';
+/** Options for setting attendee permissions */
+interface SetPermissionsOptions {
+    attendeeId: number;
+    method: PermissionMethod;
+    permissions: number;
+}
+/** Session state */
+interface SessionState {
+    /** 0 = inactive, 1 = active */
+    state: 0 | 1;
+}
+
+/**
+ * Call Types
+ *
+ * TypeScript interfaces for Nextcloud Talk call/WebRTC entities.
+ */
+/** Peer in an active call */
+interface TalkCallPeer {
+    /** Actor type of the peer */
+    actorType: string;
+    /** Actor ID of the peer */
+    actorId: string;
+    /** Display name of the peer */
+    displayName: string;
+    /** Session ID */
+    sessionId: string;
+    /** In-call flags */
+    inCall: number;
+    /** Last ping timestamp */
+    lastPing: number;
+    /** Token of the room */
+    token: string;
+}
+/** Options for joining a call */
+interface JoinCallOptions {
+    /** In-call flags (bitmask) - default is 7 (IN_CALL | WITH_AUDIO | WITH_VIDEO) */
+    flags?: number;
+    /** Join silently without notifying others */
+    silent?: boolean;
+    /** Recording consent given */
+    recordingConsent?: boolean;
+    /** Array of attendee IDs to join silently for */
+    silentFor?: number[];
+}
+/** Options for leaving a call */
+interface LeaveCallOptions {
+    /** End call for everyone (moderator only) */
+    all?: boolean;
+}
+/** Update call flags */
+interface UpdateCallFlagsOptions {
+    flags: number;
+}
+/** Signaling settings response */
+interface SignalingSettings {
+    /** Signaling mode */
+    signalingMode: 'internal' | 'external' | 'conversation_cluster';
+    /** Current user ID */
+    userId: string;
+    /** External signaling server URL */
+    server?: string;
+    /** Authentication ticket */
+    ticket?: string;
+    /** Hello auth params for external signaling */
+    helloAuthParams?: {
+        '1.0'?: {
+            userid: string;
+            ticket: string;
+        };
+        '2.0'?: {
+            token: string;
+        };
+    };
+    /** STUN servers */
+    stunservers: Array<{
+        urls: string[];
+    }>;
+    /** TURN servers */
+    turnservers: Array<{
+        urls: string[];
+        username: string;
+        credential: string;
+    }>;
+    /** SIP dial-in info */
+    sipDialinInfo?: string;
+}
+
+/**
+ * Poll Types
+ *
+ * TypeScript interfaces for Nextcloud Talk poll entities.
+ */
+/** Vote in a poll */
+interface PollVote {
+    actorType: string;
+    actorId: string;
+    actorDisplayName: string;
+    optionId: number;
+}
+/** Poll entity */
+interface TalkPoll {
+    /** Poll ID */
+    id: number;
+    /** Room token */
+    token: string;
+    /** Poll question */
+    question: string;
+    /** Poll options */
+    options: string[];
+    /** Vote counts per option */
+    votes?: Record<string, number>;
+    /** Number of voters */
+    numVoters?: number;
+    /** Result mode (0 = public, 1 = hidden) */
+    resultMode: number;
+    /** Maximum votes per user */
+    maxVotes: number;
+    /** Actor type of poll creator */
+    actorType: string;
+    /** Actor ID of poll creator */
+    actorId: string;
+    /** Display name of poll creator */
+    actorDisplayName: string;
+    /** Status (0 = open, 1 = closed) */
+    status: number;
+    /** Voted options by current user */
+    votedSelf?: number[];
+    /** All votes (if public and closed or moderator) */
+    details?: PollVote[];
+}
+/** Options for creating a poll */
+interface CreatePollOptions {
+    /** Poll question */
+    question: string;
+    /** Poll options (2-10 options) */
+    options: string[];
+    /** Result mode (0 = public, 1 = hidden) */
+    resultMode?: number;
+    /** Maximum votes per user */
+    maxVotes?: number;
+    /** Create as draft */
+    draft?: boolean;
+    /** Thread ID */
+    threadId?: number;
+}
+/** Options for voting on a poll */
+interface VotePollOptions {
+    /** Option indices to vote for */
+    optionIds: number[];
+}
+
+/**
+ * Reaction Types
+ *
+ * TypeScript interfaces for Nextcloud Talk reaction entities.
+ */
+/** Reaction actor */
+interface ReactionActor {
+    actorType: string;
+    actorId: string;
+    actorDisplayName: string;
+    timestamp: number;
+}
+/** Reactions grouped by emoji */
+type ReactionsByEmoji = Record<string, ReactionActor[]>;
+/** Options for adding a reaction */
+interface AddReactionOptions {
+    reaction: string;
+}
+
+/**
+ * Room DTO Mapper
+ *
+ * Maps raw API room data to clean domain objects,
+ * stripping OCS envelope and normalizing field names.
+ */
+
+/**
+ * Normalized room data with clean property access
+ */
+interface NormalizedRoom {
+    id: number;
+    token: string;
+    type: number;
+    name: string;
+    displayName: string;
+    description: string;
+    actorType: string;
+    actorId: string;
+    attendeeId: number;
+    participantType: number;
+    permissions: number;
+    attendeePermissions: number;
+    hasPassword: boolean;
+    hasCall: boolean;
+    callFlag: number;
+    callStartTime: number;
+    callRecording: number;
+    readOnly: number;
+    listable: number;
+    lobbyState: number;
+    lobbyTimer: number;
+    sipEnabled: number;
+    mentionPermissions: number;
+    messageExpiration: number;
+    recordingConsent: number;
+    lastActivity: number;
+    lastReadMessage: number;
+    lastCommonReadMessage: number;
+    unreadMessages: number;
+    unreadMention: boolean;
+    unreadMentionDirect: boolean;
+    canStartCall: boolean;
+    canLeaveConversation: boolean;
+    canDeleteConversation: boolean;
+    canEnableSIP: boolean;
+    isFavorite: boolean;
+    isArchived: boolean;
+    isImportant: boolean;
+    isSensitive: boolean;
+    status?: string;
+    statusIcon?: string;
+    statusMessage?: string;
+    statusClearAt?: number;
+    remoteServer?: string;
+    remoteToken?: string;
+}
+/**
+ * Map raw API room data to a normalized room object
+ *
+ * @param raw - Raw room data from API
+ * @returns Normalized room data
+ */
+declare function normalizeRoom(raw: TalkRoom): NormalizedRoom;
+/**
+ * Map an array of raw room data to normalized rooms
+ *
+ * @param rawRooms - Array of raw room data from API
+ * @returns Array of normalized room data
+ */
+declare function normalizeRooms(rawRooms: TalkRoom[]): NormalizedRoom[];
+
+/**
+ * Message DTO Mapper
+ *
+ * Maps raw API message data to clean domain objects,
+ * handling the parent message unwrapping for replies.
+ */
+
+/**
+ * Normalized message data with clean property access
+ */
+interface NormalizedMessage {
+    id: number;
+    token: string;
+    actorType: string;
+    actorId: string;
+    actorDisplayName: string;
+    timestamp: number;
+    message: string;
+    messageType: string;
+    systemMessage: string;
+    messageParameters: Record<string, TalkRichObjectParameter>;
+    isReplyable: boolean;
+    markdown: boolean;
+    referenceId: string;
+    expirationTimestamp: number;
+    reactions: Record<string, number>;
+    reactionsSelf: string[];
+    lastEditActorType?: string;
+    lastEditActorId?: string;
+    lastEditActorDisplayName?: string;
+    lastEditTimestamp?: number;
+    threadId?: number;
+    isThread: boolean;
+    threadTitle?: string;
+    threadReplies?: number;
+    parent?: NormalizedMessage | {
+        id: number;
+        deleted: true;
+    };
+    metaData?: MessageMetadata;
+}
+/**
+ * Map raw API message data to a normalized message object
+ *
+ * @param raw - Raw message data from API
+ * @returns Normalized message data
+ */
+declare function normalizeMessage(raw: TalkChatMessage): NormalizedMessage;
+/**
+ * Map raw API message with parent to a normalized message
+ *
+ * @param raw - Raw message data with optional parent
+ * @returns Normalized message with normalized parent
+ */
+declare function normalizeMessageWithParent(raw: TalkChatMessageWithParent): NormalizedMessage;
+/**
+ * Map an array of raw messages to normalized messages
+ *
+ * @param rawMessages - Array of raw message data from API
+ * @returns Array of normalized message data
+ */
+declare function normalizeMessages(rawMessages: TalkChatMessageWithParent[]): NormalizedMessage[];
+
+/**
+ * Participant DTO Mapper
+ *
+ * Maps raw API participant data to clean domain objects.
+ */
+
+/**
+ * Normalized participant data
+ */
+interface NormalizedParticipant {
+    actorType: string;
+    actorId: string;
+    displayName: string;
+    attendeeId: number;
+    participantType: number;
+    permissions: number;
+    attendeePermissions: number;
+    attendeePin: string;
+    roomToken: string;
+    sessionIds: string[];
+    inCall: number;
+    lastPing: number;
+    status?: string;
+    statusIcon?: string;
+    statusMessage?: string;
+    statusClearAt?: number;
+    phoneNumber?: string;
+    callId?: string;
+    isInCall: boolean;
+    hasAudio: boolean;
+    hasVideo: boolean;
+    isOnPhone: boolean;
+}
+/**
+ * Map raw API participant data to a normalized participant object
+ *
+ * @param raw - Raw participant data from API
+ * @returns Normalized participant data
+ */
+declare function normalizeParticipant(raw: TalkParticipant): NormalizedParticipant;
+/**
+ * Map an array of raw participants to normalized participants
+ *
+ * @param rawParticipants - Array of raw participant data from API
+ * @returns Array of normalized participant data
+ */
+declare function normalizeParticipants(rawParticipants: TalkParticipant[]): NormalizedParticipant[];
+
+/**
+ * Room Resource (API v4)
+ *
+ * Handles all room/conversation-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v4/room endpoints.
+ */
+
+/**
+ * Room resource for managing Nextcloud Talk conversations
+ *
+ * @remarks
+ * All methods use the v4 API as documented in the spec.
+ * Room operations use the token (string) as the primary identifier.
+ */
+declare class RoomResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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
+     */
+    list(options?: ListRoomsOptions): Promise<NormalizedRoom[]>;
+    /**
+     * 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
+     */
+    get(token: string): Promise<NormalizedRoom>;
+    /**
+     * 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
+     */
+    create(options: CreateRoomOptions): Promise<NormalizedRoom>;
+    /**
+     * Update room name
+     *
+     * @param token - Room token
+     * @param roomName - New room name
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    rename(token: string, roomName: string): Promise<void>;
+    /**
+     * Update room description
+     *
+     * @param token - Room token
+     * @param description - New description (max 2000 chars)
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    setDescription(token: string, description: string): Promise<void>;
+    /**
+     * Delete a room
+     *
+     * @param token - Room token
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    delete(token: string): Promise<void>;
+    /**
+     * Set room password
+     *
+     * @param token - Room token
+     * @param password - Room password (empty string to remove)
+     *
+     * @remarks
+     * Requires moderator permissions. Only for public rooms.
+     */
+    setPassword(token: string, password: string): Promise<void>;
+    /**
+     * Make room public (allow guests)
+     *
+     * @param token - Room token
+     *
+     * @remarks
+     * Requires logged-in moderator.
+     */
+    makePublic(token: string): Promise<void>;
+    /**
+     * Make room private
+     *
+     * @param token - Room token
+     *
+     * @remarks
+     * Requires logged-in moderator.
+     */
+    makePrivate(token: string): Promise<void>;
+    /**
+     * Set read-only state
+     *
+     * @param token - Room token
+     * @param state - Read-only state (0 = read-write, 1 = read-only)
+     */
+    setReadOnly(token: string, state: 0 | 1): Promise<void>;
+    /**
+     * Set listable scope
+     *
+     * @param token - Room token
+     * @param scope - Listable scope (0 = none, 1 = users, 2 = everyone)
+     */
+    setListable(token: string, scope: 0 | 1 | 2): Promise<void>;
+    /**
+     * Add room to favorites
+     *
+     * @param token - Room token
+     */
+    addToFavorites(token: string): Promise<void>;
+    /**
+     * Remove room from favorites
+     *
+     * @param token - Room token
+     */
+    removeFromFavorites(token: string): Promise<void>;
+    /**
+     * Archive room
+     *
+     * @param token - Room token
+     */
+    archive(token: string): Promise<void>;
+    /**
+     * Unarchive room
+     *
+     * @param token - Room token
+     */
+    unarchive(token: string): Promise<void>;
+    /**
+     * Mark room as important (notifications on DND)
+     *
+     * @param token - Room token
+     */
+    markImportant(token: string): Promise<void>;
+    /**
+     * Unmark room as important
+     *
+     * @param token - Room token
+     */
+    unmarkImportant(token: string): Promise<void>;
+    /**
+     * Mark room as sensitive (hide preview)
+     *
+     * @param token - Room token
+     */
+    markSensitive(token: string): Promise<void>;
+    /**
+     * Unmark room as sensitive
+     *
+     * @param token - Room token
+     */
+    unmarkSensitive(token: string): Promise<void>;
+    /**
+     * Set notification level
+     *
+     * @param token - Room token
+     * @param level - Notification level (0-3)
+     */
+    setNotificationLevel(token: string, level: 0 | 1 | 2 | 3): Promise<void>;
+    /**
+     * Set call notification setting
+     *
+     * @param token - Room token
+     * @param level - Call notification level (0 = off, 1 = on)
+     */
+    setCallNotifications(token: string, level: 0 | 1): Promise<void>;
+    /**
+     * Configure lobby
+     *
+     * @param token - Room token
+     * @param state - Lobby state (0 = disabled, 1 = enabled)
+     * @param timer - Optional Unix timestamp when lobby opens
+     */
+    setLobby(token: string, state: 0 | 1, timer?: number): Promise<void>;
+    /**
+     * Set default or call permissions for the room
+     *
+     * @param token - Room token
+     * @param mode - Permission mode ('default' or 'call')
+     * @param permissions - Permission bitmask
+     */
+    setPermissions(token: string, mode: PermissionMode, permissions: number): Promise<void>;
+    /**
+     * Set message expiration time
+     *
+     * @param token - Room token
+     * @param seconds - Expiration time in seconds (0 = never)
+     */
+    setMessageExpiration(token: string, seconds: number): Promise<void>;
+    /**
+     * Get raw response with metadata headers (for advanced use)
+     *
+     * @param token - Room token
+     * @returns Full HTTP response with data and metadata
+     */
+    getRaw(token: string): Promise<HttpResponse<TalkRoom>>;
+}
+
+/**
+ * Chat Resource (API v1)
+ *
+ * Handles all chat/messaging-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v1/chat endpoints.
+ */
+
+/**
+ * Chat resource for messaging in Nextcloud Talk conversations
+ *
+ * @remarks
+ * All methods use the v1 API as documented in the spec.
+ * The pollMessages method implements the spec's efficient update pattern.
+ */
+declare class ChatResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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)
+     */
+    receiveMessages(token: string, options: ReceiveMessagesOptions): Promise<NormalizedMessage[]>;
+    /**
+     * Get message history (past messages)
+     *
+     * @param token - Room token
+     * @param options - Optional limit and lastKnownMessageId for pagination
+     * @returns Array of normalized messages
+     */
+    getHistory(token: string, options?: {
+        limit?: number;
+        lastKnownMessageId?: number;
+    }): Promise<NormalizedMessage[]>;
+    /**
+     * 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;
+     *   }
+     * }
+     * ```
+     */
+    pollMessages(token: string, options: PollMessagesOptions): Promise<ChatPollResult>;
+    /**
+     * 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
+     */
+    sendMessage(token: string, options: SendMessageOptions): Promise<NormalizedMessage>;
+    /**
+     * Edit a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID to edit
+     * @param message - New message content
+     * @returns Updated message
+     */
+    editMessage(token: string, messageId: number, message: string): Promise<NormalizedMessage>;
+    /**
+     * Delete a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID to delete
+     * @returns Deleted message placeholder
+     */
+    deleteMessage(token: string, messageId: number): Promise<NormalizedMessage>;
+    /**
+     * 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
+     */
+    getContext(token: string, messageId: number, options?: {
+        limit?: number;
+        threadId?: number;
+    }): Promise<NormalizedMessage[]>;
+    /**
+     * Share a rich object (file, deck card, etc.)
+     *
+     * @param token - Room token
+     * @param options - Share options
+     * @returns Shared message
+     */
+    shareObject(token: string, options: ShareObjectOptions): Promise<NormalizedMessage>;
+    /**
+     * Clear chat history
+     *
+     * @param token - Room token
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    clearHistory(token: string): Promise<void>;
+    /**
+     * Set read marker to a specific message
+     *
+     * @param token - Room token
+     * @param lastReadMessage - Message ID to mark as last read
+     */
+    setReadMarker(token: string, lastReadMessage: number): Promise<void>;
+    /**
+     * Mark chat as unread
+     *
+     * @param token - Room token
+     */
+    markUnread(token: string): Promise<void>;
+    /**
+     * Search for mention suggestions
+     *
+     * @param token - Room token
+     * @param search - Search query
+     * @param options - Optional limit and includeStatus
+     * @returns Array of mention suggestions
+     */
+    searchMentions(token: string, search: string, options?: {
+        limit?: number;
+        includeStatus?: boolean;
+    }): Promise<TalkChatMentionSuggestion[]>;
+    /**
+     * 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.
+     */
+    pinMessage(token: string, messageId: number, pinUntil?: number): Promise<void>;
+    /**
+     * Unpin a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID to unpin
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    unpinMessage(token: string, messageId: number): Promise<void>;
+    /**
+     * Hide a pinned message for the current user only
+     *
+     * @param token - Room token
+     * @param messageId - Message ID to hide
+     */
+    hidePinnedMessage(token: string, messageId: number): Promise<void>;
+    /**
+     * Set a reminder for a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID
+     * @param timestamp - Unix timestamp for reminder
+     */
+    setReminder(token: string, messageId: number, timestamp: number): Promise<void>;
+    /**
+     * Delete a message reminder
+     *
+     * @param token - Room token
+     * @param messageId - Message ID
+     */
+    deleteReminder(token: string, messageId: number): Promise<void>;
+}
+
+/**
+ * Participant Resource (API v4)
+ *
+ * Handles all participant-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v4/room/{token}/participants endpoints.
+ */
+
+/**
+ * Participant resource for managing room participants
+ *
+ * @remarks
+ * All methods use the v4 API as documented in the spec.
+ */
+declare class ParticipantResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get list of participants in a room
+     *
+     * @param token - Room token
+     * @param includeStatus - Include user status information
+     * @returns Array of normalized participants
+     */
+    list(token: string, includeStatus?: boolean): Promise<NormalizedParticipant[]>;
+    /**
+     * Add a participant to a room
+     *
+     * @param token - Room token
+     * @param options - Participant options
+     *
+     * @remarks
+     * Requires logged-in moderator.
+     */
+    add(token: string, options: AddParticipantOptions): Promise<void>;
+    /**
+     * Remove a participant from a room
+     *
+     * @param token - Room token
+     * @param attendeeId - Attendee ID to remove
+     *
+     * @remarks
+     * Requires moderator permissions.
+     */
+    remove(token: string, attendeeId: number): Promise<void>;
+    /**
+     * Remove self from a room
+     *
+     * @param token - Room token
+     */
+    removeSelf(token: string): Promise<void>;
+    /**
+     * 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.
+     */
+    join(token: string, options?: JoinRoomOptions): Promise<NormalizedRoom>;
+    /**
+     * Leave a room (end session)
+     *
+     * @param token - Room token
+     */
+    leave(token: string): Promise<void>;
+    /**
+     * Set session state (active/inactive)
+     *
+     * @param token - Room token
+     * @param state - 0 = inactive, 1 = active
+     */
+    setSessionState(token: string, state: 0 | 1): Promise<void>;
+    /**
+     * Promote a participant to moderator
+     *
+     * @param token - Room token
+     * @param attendeeId - Attendee ID to promote
+     */
+    promoteModerator(token: string, attendeeId: number): Promise<void>;
+    /**
+     * Demote a moderator to regular participant
+     *
+     * @param token - Room token
+     * @param attendeeId - Attendee ID to demote
+     */
+    demoteModerator(token: string, attendeeId: number): Promise<void>;
+    /**
+     * Set permissions for an attendee
+     *
+     * @param token - Room token
+     * @param options - Permission options
+     */
+    setPermissions(token: string, options: SetPermissionsOptions): Promise<void>;
+    /**
+     * Resend invitations to pending participants
+     *
+     * @param token - Room token
+     * @param attendeeId - Optional specific attendee, or all if omitted
+     */
+    resendInvitations(token: string, attendeeId?: number): Promise<void>;
+}
+
+/**
+ * Call Resource (API v4)
+ *
+ * Handles all call/WebRTC-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v4/call endpoints.
+ */
+
+/**
+ * Call resource for managing WebRTC calls
+ *
+ * @remarks
+ * Call operations use the v4 API.
+ * Signaling settings use the v3 API.
+ */
+declare class CallResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get peers currently in a call
+     *
+     * @param token - Room token
+     * @returns Array of call peers
+     */
+    getPeers(token: string): Promise<TalkCallPeer[]>;
+    /**
+     * 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).
+     */
+    join(token: string, options?: JoinCallOptions): Promise<void>;
+    /**
+     * Update call flags (audio/video status)
+     *
+     * @param token - Room token
+     * @param flags - New in-call flags
+     */
+    updateFlags(token: string, flags: number): Promise<void>;
+    /**
+     * Leave a call
+     *
+     * @param token - Room token
+     * @param options - Leave options
+     */
+    leave(token: string, options?: LeaveCallOptions): Promise<void>;
+    /**
+     * Ring a specific attendee
+     *
+     * @param token - Room token
+     * @param attendeeId - Attendee ID to ring
+     *
+     * @remarks
+     * Requires START_CALL permission.
+     */
+    ringAttendee(token: string, attendeeId: number): Promise<void>;
+    /**
+     * Initiate SIP dial-out to a phone participant
+     *
+     * @param token - Room token
+     * @param attendeeId - Attendee ID to dial
+     */
+    dialOut(token: string, attendeeId: number): Promise<void>;
+    /**
+     * Get signaling settings for WebRTC
+     *
+     * @param token - Room token
+     * @returns Signaling configuration including STUN/TURN servers
+     */
+    getSignalingSettings(token: string): Promise<SignalingSettings>;
+    /**
+     * Enable audio in call
+     *
+     * @param token - Room token
+     * @param currentFlags - Current in-call flags
+     */
+    enableAudio(token: string, currentFlags: number): Promise<void>;
+    /**
+     * Disable audio in call
+     *
+     * @param token - Room token
+     * @param currentFlags - Current in-call flags
+     */
+    disableAudio(token: string, currentFlags: number): Promise<void>;
+    /**
+     * Enable video in call
+     *
+     * @param token - Room token
+     * @param currentFlags - Current in-call flags
+     */
+    enableVideo(token: string, currentFlags: number): Promise<void>;
+    /**
+     * Disable video in call
+     *
+     * @param token - Room token
+     * @param currentFlags - Current in-call flags
+     */
+    disableVideo(token: string, currentFlags: number): Promise<void>;
+}
+
+/**
+ * Poll Resource (API v1)
+ *
+ * Handles all poll-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v1/poll endpoints.
+ */
+
+/**
+ * Poll resource for managing polls in Nextcloud Talk
+ */
+declare class PollResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new poll
+     *
+     * @param token - Room token
+     * @param options - Poll creation options
+     * @returns Created poll
+     */
+    create(token: string, options: CreatePollOptions): Promise<TalkPoll>;
+    /**
+     * Get a poll by ID
+     *
+     * @param token - Room token
+     * @param pollId - Poll ID
+     * @returns Poll data
+     */
+    get(token: string, pollId: number): Promise<TalkPoll>;
+    /**
+     * Vote on a poll
+     *
+     * @param token - Room token
+     * @param pollId - Poll ID
+     * @param options - Vote options (option indices)
+     * @returns Updated poll
+     */
+    vote(token: string, pollId: number, options: VotePollOptions): Promise<TalkPoll>;
+    /**
+     * Close or delete a poll
+     *
+     * @param token - Room token
+     * @param pollId - Poll ID
+     * @returns Closed poll
+     */
+    close(token: string, pollId: number): Promise<TalkPoll>;
+    /**
+     * Get poll drafts
+     *
+     * @param token - Room token
+     * @returns Array of draft polls
+     */
+    getDrafts(token: string): Promise<TalkPoll[]>;
+    /**
+     * Update a poll draft
+     *
+     * @param token - Room token
+     * @param pollId - Poll draft ID
+     * @param options - Updated poll options
+     * @returns Updated draft
+     */
+    updateDraft(token: string, pollId: number, options: CreatePollOptions): Promise<TalkPoll>;
+}
+
+/**
+ * Reaction Resource (API v1)
+ *
+ * Handles all reaction-related API operations.
+ * Uses /ocs/v2.php/apps/spreed/api/v1/reaction endpoints.
+ */
+
+/**
+ * Reaction resource for managing message reactions
+ */
+declare class ReactionResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Add a reaction to a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID
+     * @param reaction - Emoji reaction (e.g., "👍")
+     * @returns Updated reactions map
+     */
+    add(token: string, messageId: number, reaction: string): Promise<ReactionsByEmoji>;
+    /**
+     * Remove a reaction from a message
+     *
+     * @param token - Room token
+     * @param messageId - Message ID
+     * @param reaction - Emoji reaction to remove
+     * @returns Updated reactions map
+     */
+    remove(token: string, messageId: number, reaction: string): Promise<ReactionsByEmoji>;
+    /**
+     * 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
+     */
+    get(token: string, messageId: number, reaction?: string): Promise<ReactionsByEmoji>;
+}
+
+/**
+ * Room Domain Entity
+ *
+ * High-level entity that encapsulates room data and provides
+ * convenient methods for common operations.
+ */
+
+/** Resources needed for Room operations */
+interface RoomResources {
+    chat: ChatResource;
+    participants: ParticipantResource;
+    call: CallResource;
+    poll: PollResource;
+    reaction: ReactionResource;
+}
+/**
+ * Room domain entity with high-level operations
+ *
+ * Encapsulates both token (string) and id (integer) to handle
+ * the API's identifier inconsistencies. All methods use token
+ * internally but id is available for legacy v1 operations.
+ *
+ * @example
+ * ```ts
+ * const room = rooms.find(r => r.token === 'abcdefgh');
+ *
+ * // Send a message
+ * await room.sendMessage("Hello world!");
+ *
+ * // Get participants
+ * const participants = await room.getParticipants();
+ *
+ * // Poll for new messages
+ * const result = await room.pollMessages({ lastKnownMessageId: 0 });
+ * ```
+ */
+declare class Room {
+    /** Room token - primary API identifier */
+    readonly token: string;
+    /** Room internal database ID */
+    readonly id: number;
+    /** Conversation type */
+    readonly type: ConversationType;
+    /** Room name */
+    readonly name: string;
+    /** Computed display name */
+    readonly displayName: string;
+    /** Room description */
+    readonly description: string;
+    /** Current user's participant type/role */
+    readonly participantType: ParticipantType;
+    /** Current user's effective permissions */
+    readonly permissions: number;
+    /** Whether room has a password */
+    readonly hasPassword: boolean;
+    /** Whether there's an active call */
+    readonly hasCall: boolean;
+    /** Read-only state */
+    readonly readOnly: ReadOnlyState;
+    /** Lobby state */
+    readonly lobbyState: LobbyState;
+    /** Number of unread messages */
+    readonly unreadMessages: number;
+    /** Whether there are unread mentions */
+    readonly unreadMention: boolean;
+    /** Whether this is a favorite room */
+    readonly isFavorite: boolean;
+    /** Whether this room is archived */
+    readonly isArchived: boolean;
+    /** Last activity timestamp */
+    readonly lastActivity: number;
+    /** Raw normalized data for advanced access */
+    readonly _data: NormalizedRoom;
+    private readonly resources;
+    constructor(data: NormalizedRoom, resources: RoomResources);
+    /**
+     * Send a message to this room
+     *
+     * @param message - Message content or full options
+     * @returns Sent message
+     */
+    sendMessage(message: string | SendMessageOptions): Promise<NormalizedMessage>;
+    /**
+     * Get message history
+     *
+     * @param options - Optional limit and pagination
+     * @returns Array of messages
+     */
+    getHistory(options?: {
+        limit?: number;
+        lastKnownMessageId?: number;
+    }): Promise<NormalizedMessage[]>;
+    /**
+     * Poll for new messages (long-polling)
+     *
+     * @param options - Poll options with lastKnownMessageId
+     * @returns Poll result with messages and metadata
+     */
+    pollMessages(options: PollMessagesOptions): Promise<ChatPollResult>;
+    /**
+     * Edit a message
+     *
+     * @param messageId - Message ID to edit
+     * @param newContent - New message content
+     * @returns Updated message
+     */
+    editMessage(messageId: number, newContent: string): Promise<NormalizedMessage>;
+    /**
+     * Delete a message
+     *
+     * @param messageId - Message ID to delete
+     * @returns Deleted message placeholder
+     */
+    deleteMessage(messageId: number): Promise<NormalizedMessage>;
+    /**
+     * Set the read marker
+     *
+     * @param lastReadMessage - Message ID to mark as last read
+     */
+    setReadMarker(lastReadMessage: number): Promise<void>;
+    /**
+     * Get participants in this room
+     *
+     * @param includeStatus - Include user status information
+     * @returns Array of participants
+     */
+    getParticipants(includeStatus?: boolean): Promise<NormalizedParticipant[]>;
+    /**
+     * Add a user to this room
+     *
+     * @param userId - User ID to add
+     * @param source - Source type (default: 'users')
+     */
+    addParticipant(userId: string, source?: 'users' | 'groups' | 'emails'): Promise<void>;
+    /**
+     * Remove a participant from this room
+     *
+     * @param attendeeId - Attendee ID to remove
+     */
+    removeParticipant(attendeeId: number): Promise<void>;
+    /**
+     * Leave this room
+     */
+    leave(): Promise<void>;
+    /**
+     * Get peers currently in the call
+     *
+     * @returns Array of call peers
+     */
+    getCallPeers(): Promise<TalkCallPeer[]>;
+    /**
+     * Join the call
+     *
+     * @param options - Join options (flags, silent, etc.)
+     */
+    joinCall(options?: JoinCallOptions): Promise<void>;
+    /**
+     * Leave the call
+     *
+     * @param endForAll - End call for everyone (moderator only)
+     */
+    leaveCall(endForAll?: boolean): Promise<void>;
+    /**
+     * Create a poll in this room
+     *
+     * @param options - Poll creation options
+     * @returns Created poll
+     */
+    createPoll(options: CreatePollOptions): Promise<TalkPoll>;
+    /**
+     * Add a reaction to a message
+     *
+     * @param messageId - Message ID
+     * @param reaction - Emoji reaction
+     */
+    addReaction(messageId: number, reaction: string): Promise<void>;
+    /**
+     * Remove a reaction from a message
+     *
+     * @param messageId - Message ID
+     * @param reaction - Emoji reaction to remove
+     */
+    removeReaction(messageId: number, reaction: string): Promise<void>;
+    /** Whether the current user is a moderator or owner */
+    get isModerator(): boolean;
+    /** Whether this is a one-to-one conversation */
+    get isOneToOne(): boolean;
+    /** Whether this is a group conversation */
+    get isGroup(): boolean;
+    /** Whether this is a public (open) conversation */
+    get isPublic(): boolean;
+    /** Whether the room is currently read-only */
+    get isReadOnly(): boolean;
+    /** Whether the lobby is enabled */
+    get hasLobby(): boolean;
+}
+
+/**
+ * TalkClient - Main entry point for the Nextcloud Talk SDK
+ *
+ * Provides a high-level interface for interacting with the Nextcloud Talk API.
+ * Uses a 4-layer architecture:
+ * - Transport: HTTP client with OCS headers
+ * - Resource: API endpoint modules (v1/v4)
+ * - Normalization: DTO mappers
+ * - Domain: High-level entities (Room)
+ */
+
+/** Configuration options for TalkClient */
+interface TalkClientConfig {
+    /** Nextcloud server host URL (e.g., 'https://nextcloud.local') */
+    host: string;
+    /** Nextcloud username */
+    username: string;
+    /** App password or regular password */
+    password: string;
+    /** Optional custom fetch implementation */
+    fetch?: typeof fetch;
+}
+/**
+ * Rooms accessor for listing and creating rooms
+ *
+ * Provides methods to interact with rooms and returns Room domain entities.
+ */
+declare class RoomsAccessor {
+    private readonly roomResource;
+    private readonly roomResources;
+    constructor(roomResource: RoomResource, 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');
+     * ```
+     */
+    list(options?: ListRoomsOptions): Promise<Room[]>;
+    /**
+     * Get a single room by token
+     *
+     * @param token - Room token
+     * @returns Room entity
+     */
+    get(token: string): Promise<Room>;
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    create(options: CreateRoomOptions): Promise<Room>;
+    /**
+     * Delete a room
+     *
+     * @param token - Room token
+     */
+    delete(token: string): Promise<void>;
+    /**
+     * Rename a room
+     *
+     * @param token - Room token
+     * @param name - New room name
+     */
+    rename(token: string, name: string): Promise<void>;
+}
+/**
+ * TalkClient - Main SDK client for Nextcloud Talk
+ *
+ * @example
+ * ```ts
+ * const client = new TalkClient({
+ *   host: 'https://nextcloud.local',
+ *   username: 'admin',
+ *   password: 'app-password'
+ * });
+ *
+ * // List rooms
+ * const rooms = await client.rooms.list();
+ *
+ * // Find and interact with a room
+ * const targetRoom = rooms.find(r => r.token === 'abcdefgh');
+ * await targetRoom.sendMessage("Automated system check initialized.");
+ *
+ * // Poll for new messages
+ * const result = await targetRoom.pollMessages({ lastKnownMessageId: 0 });
+ * ```
+ */
+declare class TalkClient {
+    /** HTTP client for direct API access */
+    readonly http: HttpClient;
+    /** Rooms accessor for room operations */
+    readonly rooms: RoomsAccessor;
+    /** Direct access to chat resource */
+    readonly chat: ChatResource;
+    /** Direct access to participant resource */
+    readonly participants: ParticipantResource;
+    /** Direct access to call resource */
+    readonly call: CallResource;
+    /** Direct access to poll resource */
+    readonly poll: PollResource;
+    /** Direct access to reaction resource */
+    readonly reaction: ReactionResource;
+    /** Direct access to room resource */
+    private readonly roomResource;
+    constructor(config: TalkClientConfig);
+    /**
+     * Get the base URL for this client
+     */
+    get host(): string;
+}
+
+export { ActorType, type AddParticipantOptions, type AddReactionOptions, BreakoutRoomMode, type CallNotificationSettings, CallResource, type ChatPollResult, ChatResource, ConversationType, type CreatePollOptions, type CreateRoomOptions, type DeletedMessageRef, HttpClient, type HttpClientConfig, HttpClientError, type HttpResponse, InCallFlag, type JoinCallOptions, type JoinRoomOptions, type LeaveCallOptions, type ListRoomsOptions, ListableScope, type LobbySettings, LobbyState, type MessageMetadata, type MessageReminder, MessageType, type NormalizedMessage, type NormalizedParticipant, type NormalizedRoom, NotificationLevel, type NotificationSettings, type OCSResponse, ParticipantResource, ParticipantType, Permission, type PermissionMethod, type PermissionMode, type PollMessagesOptions, PollResource, PollResultMode, type PollVote, type ReactionActor, ReactionResource, type ReactionsByEmoji, ReadOnlyState, type ReceiveMessagesOptions, RecordingStatus, type RequestOptions, type ResponseMeta, Room, RoomResource, type RoomResources, RoomsAccessor, SIPState, type ScheduleMessageOptions, type SendMessageOptions, type SessionConflict, type SessionState, type SetPermissionsOptions, type ShareObjectOptions, SharedObjectType, type SignalingSettings, type TalkCallPeer, type TalkChatMentionSuggestion, type TalkChatMessage, type TalkChatMessageWithParent, TalkClient, type TalkClientConfig, type TalkParticipant, type TalkPoll, type TalkRichObjectParameter, type TalkRoom, type UpdateCallFlagsOptions, type VotePollOptions, normalizeMessage, normalizeMessageWithParent, normalizeMessages, normalizeParticipant, normalizeParticipants, normalizeRoom, normalizeRooms };