@theophilusdev/conduit 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,648 @@
+import { MessengerBotOptions, MessengerBot } from '@dongdev/fca-unofficial';
+
+/**
+ * A loose string type — behaves like `string` at runtime but preserves
+ * literal union autocomplete in the IDE via the `string & {}` trick.
+ */
+type Loose = string & {};
+/** Configuration options for the Conduit client. Extends {@link MessengerBotOptions}. */
+interface ConduitClientConfig extends MessengerBotOptions {
+}
+/**
+ * Credentials used to authenticate the Conduit client with Facebook.
+ *
+ * Provide **one** of the following strategies (in order of recommendation):
+ * - `appstate` — array of appstate objects exported from a browser extension
+ * - `cookies` — raw cookie header string (`"c_user=...; xs=..."`)
+ * - `account` — email/password fallback (not recommended for production)
+ */
+interface ConduitCredentials {
+    /** Facebook appstate — array of cookie-like objects. Recommended. */
+    appstate?: Loose[];
+    /** Raw cookie header string. */
+    cookies?: Loose;
+    /** Email/password login. Easily triggers checkpoints; avoid in production. */
+    account?: {
+        email: Loose;
+        password: Loose;
+    };
+}
+/**
+ * A message object shared across message events.
+ * Attachments are loosely typed until all shapes are confirmed.
+ */
+interface Message {
+    threadID: string;
+    messageID: string;
+    senderID: string;
+    body: string;
+    attachments: any[];
+    mentions: Record<string, string>;
+    timestamp: string;
+    participantIDs: string[];
+}
+/**
+ * Base shape shared across all thread events fanned out from FCA `threadUpdate`.
+ * All thread sub-events include at minimum these fields.
+ */
+interface ThreadEventBase {
+    threadID: string;
+    /** The user who performed the action. */
+    author: string;
+    participantIDs: string[];
+}
+/** Available on all Conduit event payloads. */
+interface Sendable {
+    /** Send a message to the same thread. */
+    send(body: string): Promise<void>;
+}
+/** Available on message events only (`message:*`). */
+interface Replyable extends Sendable {
+    /** Reply to this specific message. */
+    reply(body: string): Promise<void>;
+    /** React to this specific message with an emoji. */
+    react(emoji: string): Promise<void>;
+}
+/**
+ * Emitted when a new message is received. Maps to FCA `message`.
+ *
+ * @note FCA inconsistency: `timestamp` arrives as a string here,
+ * unlike `message_reply` where it is a number.
+ */
+interface MessageCreatePayload extends Message, Replyable {
+    isGroup: boolean;
+}
+/** Emitted when a user replies to a message. Maps to FCA `message_reply`. */
+interface MessageRespondPayload extends Message, Replyable {
+    isGroup: boolean;
+    /** The message being replied to. */
+    messageReply: Message;
+}
+/** Emitted when a message is unsent by its sender. Maps to FCA `message_unsend`. */
+interface MessageRemovePayload extends Sendable {
+    threadID: string;
+    messageID: string;
+    senderID: string;
+    deletionTimestamp: number;
+}
+/** Emitted when a reaction is added or removed on a message. Maps to FCA `message_reaction`. */
+interface MessageReactPayload extends Sendable {
+    threadID: string;
+    messageID: string;
+    /** The user who owns the message. */
+    senderID: string;
+    /** The user who reacted. */
+    reactorID: string;
+    reaction: string;
+}
+/** Emitted when a user starts or stops typing. Maps to FCA `typ`. */
+interface MessageWritingPayload extends Sendable {
+    threadID: string;
+    senderID: string;
+    isTyping: boolean;
+}
+/** Emitted when a thread or message is marked as read. Maps to FCA `read_receipt`. */
+interface MessageReadPayload extends Sendable {
+    threadID: string;
+    readerID: string;
+    time: string;
+}
+/**
+ * Emitted on any thread metadata change. Catch-all for the raw FCA `threadUpdate` event.
+ * For specific changes, prefer the narrower `thread:*` events.
+ */
+interface ThreadUpdatePayload extends ThreadEventBase, Sendable {
+    logMessageType: string;
+    logMessageData: Record<string, any>;
+}
+/** Emitted when the group thread title is changed. Maps to FCA `threadUpdate` → `log:thread-name`. */
+interface ThreadTitleChangePayload extends ThreadEventBase, Sendable {
+    /** The new thread title. */
+    name: string;
+}
+/** Emitted when the group photo is changed. Maps to FCA `threadUpdate` → `log:thread-image`. */
+interface ThreadPhotoReplacedPayload extends ThreadEventBase, Sendable {
+    image: {
+        attachmentID: string;
+        width: number;
+        height: number;
+        url: string;
+    };
+    timestamp: string;
+}
+/** Emitted when the chat theme or color is changed. Maps to FCA `threadUpdate` → `log:thread-color`. */
+interface ThreadThemeChangedPayload extends ThreadEventBase, Sendable {
+    themeColor: string;
+    gradient: string;
+    themeID: string;
+    accessibilityLabel: string;
+    themeName: string;
+    themeEmoji: string;
+}
+/** Emitted when a participant's nickname is changed. Maps to FCA `threadUpdate` → `log:user-nickname`. */
+interface ThreadNicknameChangedPayload extends ThreadEventBase, Sendable {
+    /** The participant whose nickname was changed. */
+    participantID: string;
+    /** The new nickname. Empty string if cleared. */
+    nickname: string;
+}
+/** Emitted when a participant's admin status is changed. Maps to FCA `threadUpdate` → `log:thread-admins`. */
+interface ThreadAdminChangedPayload extends ThreadEventBase, Sendable {
+    /** The participant whose admin status changed. */
+    targetID: string;
+    /** Whether the participant was promoted or demoted. */
+    adminEvent: "add_admin" | "remove_admin";
+}
+/** A participant added to a group thread. */
+interface AddedParticipant {
+    fbid: string;
+    fullName: string;
+}
+/** Emitted when a user is added to a group thread. Maps to FCA `threadUpdate` → `log:subscribe`. */
+interface UserCreatePayload extends ThreadEventBase, Sendable {
+    addedParticipants: AddedParticipant[];
+}
+/** Emitted when a user is removed from or leaves a group thread. Maps to FCA `threadUpdate` → `log:unsubscribe`. */
+interface UserRemovePayload extends ThreadEventBase, Sendable {
+    /** The fbid of the participant who left or was removed. */
+    leftParticipantFbID: string;
+}
+/**
+ * All events emitted by the Conduit event bus.
+ *
+ * Thread sub-events (join, leave, title change, etc.) arrive as `threadUpdate` from
+ * FCA with a `logMessageType` discriminant — Conduit fans those out into the
+ * specific `thread:*` and `user:*` events below.
+ *
+ * @see https://github.com/dongp06/fca-unofficial — Section 15: Events Reference
+ */
+interface ConduitEvents {
+    /** A new message was received. Maps to FCA `message`. */
+    "message:create": (data: MessageCreatePayload) => Promise<any>;
+    /** A message was unsent by its sender. Maps to FCA `message_unsend`. */
+    "message:remove": (data: MessageRemovePayload) => Promise<any>;
+    /** A reaction was added or removed on a message. Maps to FCA `message_reaction`. */
+    "message:react": (data: MessageReactPayload) => Promise<any>;
+    /** A reply was sent to an existing message. Maps to FCA `message_reply`. */
+    "message:respond": (data: MessageRespondPayload) => Promise<any>;
+    /** A user started or stopped typing. Maps to FCA `typ`. Requires `listenTyping: true`. */
+    "message:writing": (data: MessageWritingPayload) => Promise<any>;
+    /** A thread or message was marked as read. Maps to FCA `read_receipt`. */
+    "message:read": (data: MessageReadPayload) => Promise<any>;
+    /** A user was added to a group thread. Maps to FCA `threadUpdate` → `log:subscribe`. */
+    "user:create": (data: UserCreatePayload) => Promise<any>;
+    /** A user was removed from or left a group thread. Maps to FCA `threadUpdate` → `log:unsubscribe`. */
+    "user:remove": (data: UserRemovePayload) => Promise<any>;
+    /** Thread metadata changed (catch-all). Maps to raw FCA `threadUpdate`. */
+    "thread:update": (data: ThreadUpdatePayload) => Promise<any>;
+    /** The thread title was changed. Maps to FCA `threadUpdate` → `log:thread-name`. */
+    "thread:title_change": (data: ThreadTitleChangePayload) => Promise<any>;
+    /** The thread photo was changed. Maps to FCA `threadUpdate` → `log:thread-image`. */
+    "thread:photo_replaced": (data: ThreadPhotoReplacedPayload) => Promise<any>;
+    /** The thread theme/color was changed. Maps to FCA `threadUpdate` → `log:thread-color`. */
+    "thread:theme_changed": (data: ThreadThemeChangedPayload) => Promise<any>;
+    /** A participant's nickname was changed. Maps to FCA `threadUpdate` → `log:user-nickname`. */
+    "thread:nickname_changed": (data: ThreadNicknameChangedPayload) => Promise<any>;
+    /** A participant's admin status was changed. Maps to FCA `threadUpdate` → `log:thread-admins`. */
+    "thread:admin_changed": (data: ThreadAdminChangedPayload) => Promise<any>;
+}
+/** A middleware function for a specific Conduit event. */
+type Middleware<K extends keyof ConduitEvents> = (data: Parameters<ConduitEvents[K]> extends [infer First, ...any[]] ? First : never, next?: () => Promise<void>) => Promise<void>;
+
+/**
+ * Provides message-related API methods wrapping the underlying FCA client.
+ * Accessible via `client.messages`.
+ */
+declare class ConduitMessagesAPI {
+    private readonly bot;
+    constructor(bot: MessengerBot);
+    /**
+     * Sends a message to a thread.
+     * @param body - The message text.
+     * @param threadID - The target thread ID.
+     */
+    send(body: string, threadID: string): Promise<any>;
+    /**
+     * Sends a quoted reply to a specific message.
+     * @param body - The reply text.
+     * @param threadID - The target thread ID.
+     * @param messageID - The message ID to reply to.
+     */
+    reply(body: string, threadID: string, messageID: string): Promise<any>;
+    /**
+     * Edits an existing message.
+     * @param messageID - The message ID to edit.
+     * @param body - The new message text.
+     */
+    edit(messageID: string, body: string): Promise<any>;
+    /**
+     * Unsends (retracts) a message sent by the bot.
+     * @param messageID - The message ID to unsend.
+     */
+    unsend(messageID: string): Promise<any>;
+    /**
+     * Deletes a message.
+     * @param messageID - The message ID to delete.
+     */
+    delete(messageID: string): Promise<any>;
+    /**
+     * Adds or removes a reaction on a message.
+     * @param emoji - The emoji reaction string.
+     * @param messageID - The target message ID.
+     * @param threadID - The thread the message belongs to.
+     */
+    react(emoji: string, messageID: string, threadID: string): Promise<any>;
+    /**
+     * Sends a typing indicator to a thread.
+     * @param threadID - The target thread ID.
+     */
+    sendTypingIndicator(threadID: string): Promise<any>;
+    /**
+     * Marks a message as read.
+     * @param messageID - The message ID to mark as read.
+     */
+    markAsRead(messageID: string): Promise<any>;
+    /**
+     * Uploads a file attachment and returns an attachment object.
+     * @param file - A readable stream or file buffer.
+     */
+    uploadAttachment(file: any): Promise<any>;
+    /**
+     * Forwards an existing attachment to another thread.
+     * @param attachmentID - The attachment ID to forward.
+     * @param threadID - The target thread ID.
+     */
+    forwardAttachment(attachmentID: string, threadID: string): Promise<any>;
+    /**
+     * Shares a contact card to a thread.
+     * @param userID - The user ID of the contact to share.
+     * @param threadID - The target thread ID.
+     */
+    shareContact(userID: string, threadID: string): Promise<any>;
+    /**
+     * Changes the color theme of a thread.
+     * @param color - The color hex string.
+     * @param threadID - The target thread ID.
+     */
+    changeThreadColor(color: string, threadID: string): Promise<any>;
+    /**
+     * Changes the quick-reaction emoji of a thread.
+     * @param emoji - The emoji string.
+     * @param threadID - The target thread ID.
+     */
+    changeThreadEmoji(emoji: string, threadID: string): Promise<any>;
+    /**
+     * Fetches a specific message by ID.
+     * @param messageID - The message ID to fetch.
+     */
+    getMessage(messageID: string): Promise<any>;
+    /**
+     * Returns all available thread color themes.
+     */
+    getThreadColors(): Promise<any>;
+}
+
+/**
+ * Provides thread-related API methods wrapping the underlying FCA client.
+ * Accessible via `client.threads`.
+ */
+declare class ConduitThreadsAPI {
+    private readonly bot;
+    constructor(bot: MessengerBot);
+    /**
+     * Fetches detailed info about a thread.
+     * @param threadID - The thread ID to query.
+     */
+    getInfo(threadID: string): Promise<any>;
+    /**
+     * Fetches a paginated list of threads.
+     * @param limit - Number of threads to return.
+     * @param cursor - Pagination cursor, or `null` for the first page.
+     * @param folders - Folder filters e.g. `["INBOX"]`.
+     */
+    getList(limit: number, cursor: any, folders: string[]): Promise<any>;
+    /**
+     * Fetches message history for a thread.
+     * @param threadID - The thread ID to query.
+     * @param limit - Number of messages to return.
+     */
+    getHistory(threadID: string, limit: number): Promise<any>;
+    /**
+     * Searches for threads by name or keyword.
+     * @param query - The search query string.
+     */
+    search(query: string): Promise<any>;
+    /**
+     * Creates a new group conversation.
+     * @param userIDs - Array of user IDs to add to the group.
+     * @param name - Optional group name.
+     */
+    createGroup(userIDs: string[], name?: string): Promise<any>;
+    /**
+     * Adds a user to an existing group thread.
+     * @param userID - The user ID to add.
+     * @param threadID - The target group thread ID.
+     */
+    addUser(userID: string, threadID: string): Promise<any>;
+    /**
+     * Removes a user from a group thread.
+     * @param userID - The user ID to remove.
+     * @param threadID - The target group thread ID.
+     */
+    removeUser(userID: string, threadID: string): Promise<any>;
+    /**
+     * Promotes or demotes a user's admin status in a group.
+     * @param userID - The target user ID.
+     * @param threadID - The group thread ID.
+     * @param admin - `true` to promote, `false` to demote.
+     */
+    changeAdminStatus(userID: string, threadID: string, admin: boolean): Promise<any>;
+    /**
+     * Updates the group's profile image.
+     * @param image - A readable stream or file buffer.
+     * @param threadID - The target group thread ID.
+     */
+    changeGroupImage(image: any, threadID: string): Promise<any>;
+    /**
+     * Sets a participant's nickname in a thread.
+     * @param nickname - The new nickname. Pass an empty string to clear.
+     * @param threadID - The thread ID.
+     * @param userID - The target user ID.
+     */
+    changeNickname(nickname: string, threadID: string, userID: string): Promise<any>;
+    /**
+     * Changes the title of a group thread.
+     * @param title - The new group title.
+     * @param threadID - The target group thread ID.
+     */
+    setTitle(title: string, threadID: string): Promise<any>;
+    /**
+     * Creates a poll in a thread.
+     * @param title - The poll question.
+     * @param threadID - The target thread ID.
+     * @param options - Array of answer options.
+     */
+    createPoll(title: string, threadID: string, options: string[]): Promise<any>;
+    /**
+     * Deletes a thread.
+     * @param threadID - The thread ID to delete.
+     */
+    delete(threadID: string): Promise<any>;
+    /**
+     * Mutes or unmutes notifications for a thread.
+     * @param threadID - The target thread ID.
+     * @param muteUntil - Timestamp (ms) to mute until. Pass `-1` to mute indefinitely, `0` to unmute.
+     */
+    mute(threadID: string, muteUntil: number): Promise<any>;
+    /**
+     * Accepts or declines a message request.
+     * @param threadID - The thread ID of the request.
+     * @param accept - `true` to accept, `false` to decline.
+     */
+    handleMessageRequest(threadID: string, accept: boolean): Promise<any>;
+}
+
+/**
+ * Provides user-related API methods wrapping the underlying FCA client.
+ * Accessible via `client.users`.
+ */
+declare class ConduitUsersAPI {
+    private readonly bot;
+    constructor(bot: MessengerBot);
+    /**
+     * Fetches info for one or more users by ID.
+     * @param userID - A single user ID or an array of user IDs.
+     */
+    getInfo(userID: string | string[]): Promise<any>;
+    /**
+     * Resolves a vanity URL or username to a Facebook user ID.
+     * @param vanity - The vanity name or profile URL slug.
+     */
+    getID(vanity: string): Promise<any>;
+    /**
+     * Returns the authenticated user's friends list.
+     */
+    getFriendsList(): Promise<any>;
+}
+
+/**
+ * Provides account-related API methods wrapping the underlying FCA client.
+ * Accessible via `client.account`.
+ */
+declare class ConduitAccountAPI {
+    private readonly bot;
+    constructor(bot: MessengerBot);
+    /**
+     * Returns the logged-in user's Facebook ID.
+     */
+    getCurrentUserID(): string;
+    /**
+     * Blocks or unblocks a user.
+     * @param userID - The target user ID.
+     * @param block - `true` to block, `false` to unblock.
+     */
+    blockUser(userID: string, block: boolean): Promise<any>;
+    /**
+     * Accepts or declines a friend request.
+     * @param userID - The user ID who sent the request.
+     * @param accept - `true` to accept, `false` to decline.
+     */
+    handleFriendRequest(userID: string, accept: boolean): Promise<any>;
+    /**
+     * Removes a user from the friends list.
+     * @param userID - The target user ID.
+     */
+    unfriend(userID: string): Promise<any>;
+    /**
+     * Ends the current session and invalidates cookies.
+     */
+    logout(): Promise<any>;
+}
+
+/**
+ * High-level Messenger client that wraps the FCA unofficial API and exposes
+ * a middleware-based event system modelled after Express/Koa.
+ *
+ * @example
+ * ```ts
+ * const conduit = new ConduitClient(config);
+ * await conduit.login(credentials);
+ * conduit.on("message:text", async (ctx, next) => {
+ *   console.log(ctx.body);
+ *   await next();
+ * });
+ * ```
+ */
+declare class ConduitClient {
+    /** Underlying FCA bot instance. `null` until {@link login} resolves. */
+    private _client;
+    /** Lazily-initialized messages API wrapper. */
+    private _messages;
+    /** Lazily-initialized threads API wrapper. */
+    private _threads;
+    /** Lazily-initialized users API wrapper. */
+    private _users;
+    /** Lazily-initialized account API wrapper. */
+    private _account;
+    /** Configuration forwarded to the FCA layer on login. */
+    private config;
+    /**
+     * Registry of middleware stacks keyed by Conduit event name.
+     * Each stack is executed in insertion order via {@link runStack}.
+     */
+    private middlewares;
+    /**
+     * Guards against registering the `threadUpdate` fan-out listener more than once,
+     * regardless of how many fan-out events are subscribed to.
+     */
+    private fanOutBound;
+    /**
+     * @param config - Client configuration passed through to the FCA bot.
+     */
+    constructor(config: ConduitClientConfig);
+    /**
+     * API for message operations.
+     *
+     * Provides methods for sending messages, replying to threads,
+     * reacting to messages, editing content, deleting messages,
+     * and other message-level interactions.
+     */
+    get messages(): ConduitMessagesAPI;
+    /**
+     * API for thread management operations.
+     *
+     * Includes functionality for retrieving thread data,
+     * managing participants, updating thread metadata (such as title),
+     * and handling thread-level features like polls.
+     */
+    get threads(): ConduitThreadsAPI;
+    /**
+     * API for user-related operations.
+     *
+     * Supports fetching user profiles, resolving user IDs,
+     * and accessing social graph data such as friends or connections.
+     */
+    get users(): ConduitUsersAPI;
+    /**
+     * API for account-level operations.
+     *
+     * Exposes actions tied to the authenticated account such as
+     * retrieving the current user ID, managing friend requests,
+     * blocking users, and logging out.
+     */
+    get account(): ConduitAccountAPI;
+    /**
+     * Authenticates with Messenger and initialises the underlying FCA bot.
+     * Must be called before any events can be received.
+     *
+     * @param credentials - App-state, cookies, or email/password credentials.
+     * @returns The current instance for chaining.
+     */
+    login(credentials: ConduitCredentials): Promise<this>;
+    /**
+     * Registers one or more middleware handlers for a Conduit event.
+     *
+     * The first call for a given event also binds the corresponding FCA listener.
+     * Fan-out events share a single `threadUpdate` FCA binding; all others get
+     * their own dedicated listener via {@link bindConduitEvent}.
+     *
+     * @param event - The Conduit event name to subscribe to.
+     * @param middlewares - Ordered middleware functions to push onto the stack.
+     * @returns The current instance for chaining.
+     */
+    on<K extends keyof ConduitEvents>(event: K, ...middlewares: Middleware<K>[]): this;
+    /**
+     * Registers middleware directly against a raw FCA event, bypassing the
+     * Conduit event abstraction entirely. Useful for events not yet mapped
+     * by the Conduit layer.
+     *
+     * @param event - Raw FCA event name.
+     * @param middlewares - Middleware functions receiving the raw FCA payload.
+     * @returns The current instance for chaining.
+     */
+    onFca(event: string, ...middlewares: ((data: any, next?: () => Promise<void>) => Promise<void>)[]): this;
+    /**
+     * Uses the raw legacy api. Not recommended as this do not
+     * have any type safety and auto-completion features. Use
+     * at your own risk.
+     *
+     * @returns The raw api context.
+     * */
+    get api(): any;
+    /**
+     * Translates a single Conduit event to its FCA equivalent and attaches a
+     * listener that enriches the raw payload before running the middleware stack.
+     *
+     * @param event - The Conduit event to bind.
+     */
+    private bindConduitEvent;
+    /**
+     * Returns the initialized Messenger client instance.
+     *
+     * This getter enforces the client lifecycle by ensuring that the underlying
+     * FCA bot has been created via {@link login} before any access is allowed.
+     *
+     * @throws {ConduitError} If the client has not been initialized yet (login not called).
+     * @returns {MessengerBot} The active Messenger bot instance.
+     */
+    private get client();
+    /**
+     * Attaches a single `threadUpdate` FCA listener that fans out to all
+     * relevant Conduit events based on the incoming `logMessageType`.
+     *
+     * `thread:update` always fires with the raw payload when its stack is
+     * non-empty. Specific sub-events (e.g. `thread:title_change`) fire only
+     * when their stack is also non-empty and a matching `logMessageType` exists.
+     *
+     * Calling this method more than once is a no-op.
+     */
+    private bindFanOutEvents;
+    /**
+     * Augments a raw FCA payload with convenience helpers scoped to the event.
+     *
+     * All events receive a `send` helper for replying to the source thread.
+     * Events in the `message:` namespace additionally receive:
+     * - `reply` — sends a quoted reply to the triggering message.
+     * - `react` — sets an emoji reaction on the triggering message.
+     *
+     * @param event - The Conduit event being enriched.
+     * @param raw - The raw FCA payload.
+     * @returns The enriched context object passed to middleware.
+     */
+    private enrich;
+    /**
+     * Executes a middleware stack sequentially, where each handler must call
+     * `next()` to advance to the following handler.
+     *
+     * @param stack - Ordered array of middleware functions to execute.
+     * @param data - The enriched event payload threaded through the stack.
+     */
+    private runStack;
+}
+
+declare const FCA_EVENT_MAP: {
+    readonly "message:create": "message";
+    readonly "message:remove": "message_unsend";
+    readonly "message:react": "message_reaction";
+    readonly "message:respond": "message_reply";
+    readonly "message:writing": "typ";
+    readonly "message:read": "read_receipt";
+    readonly "user:create": "event";
+    readonly "user:remove": "event";
+    readonly "thread:update": "event";
+    readonly "thread:title_change": "event";
+    readonly "thread:photo_replaced": "event";
+    readonly "thread:theme_changed": "event";
+    readonly "thread:nickname_changed": "event";
+    readonly "thread:admin_changed": "event";
+};
+type FcaEventName = (typeof FCA_EVENT_MAP)[keyof typeof FCA_EVENT_MAP];
+declare function toFcaEvent(event: keyof ConduitEvents): FcaEventName;
+
+declare class ConduitError extends Error {
+    constructor(message: string);
+    static new(message: string): ConduitError;
+    static uninitializedClient(): ConduitError;
+}
+
+export { type AddedParticipant, ConduitAccountAPI, ConduitClient, type ConduitClientConfig, type ConduitCredentials, ConduitError, type ConduitEvents, ConduitMessagesAPI, ConduitThreadsAPI, ConduitUsersAPI, type Loose, type Message, type MessageCreatePayload, type MessageReactPayload, type MessageReadPayload, type MessageRemovePayload, type MessageRespondPayload, type MessageWritingPayload, type Middleware, type Replyable, type Sendable, type ThreadAdminChangedPayload, type ThreadEventBase, type ThreadNicknameChangedPayload, type ThreadPhotoReplacedPayload, type ThreadThemeChangedPayload, type ThreadTitleChangePayload, type ThreadUpdatePayload, type UserCreatePayload, type UserRemovePayload, toFcaEvent };