@xmtp/node-sdk 1.2.1 → 2.0.1

package/dist/index.js

@@ -126,6 +126,26 @@ function nsToDate(ns) {
     return new Date(ns / 1_000_000);
 }
 
+/**
+ * Represents a decoded XMTP message
+ *
+ * This class transforms network messages into a structured format with
+ * content decoding.
+ *
+ * @class
+ * @property {any} content - The decoded content of the message
+ * @property {ContentTypeId} contentType - The content type of the message content
+ * @property {string} conversationId - Unique identifier for the conversation
+ * @property {MessageDeliveryStatus} deliveryStatus - Current delivery status of the message ("unpublished" | "published" | "failed")
+ * @property {string} [fallback] - Optional fallback text for the message
+ * @property {number} [compression] - Optional compression level applied to the message
+ * @property {string} id - Unique identifier for the message
+ * @property {MessageKind} kind - Type of message ("application" | "membership_change")
+ * @property {Record<string, string>} parameters - Additional parameters associated with the message
+ * @property {string} senderInboxId - Identifier for the sender's inbox
+ * @property {Date} sentAt - Timestamp when the message was sent
+ * @property {number} sentAtNs - Timestamp when the message was sent (in nanoseconds)
+ */
 class DecodedMessage {
     #client;
     content;
@@ -174,10 +194,15 @@ class DecodedMessage {
         this.parameters = message.content.parameters;
         this.fallback = message.content.fallback;
         this.compression = message.content.compression;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        this.content = this.contentType
-            ? this.#client.decodeContent(message, this.contentType)
-            : undefined;
+        this.content = undefined;
+        if (this.contentType) {
+            try {
+                this.content = this.#client.decodeContent(message, this.contentType);
+            }
+            catch {
+                this.content = undefined;
+            }
+        }
     }
 }
 
@@ -229,11 +254,33 @@ class MissingContentTypeError extends Error {
         super("Content type is required when sending content other than text");
     }
 }
+class SignerUnavailableError extends Error {
+    constructor() {
+        super("Signer unavailable, use Client.create to create a client with a signer");
+    }
+}
+class ClientNotInitializedError extends Error {
+    constructor() {
+        super("Client not initialized, use Client.create or Client.build to create a client");
+    }
+}
 
+/**
+ * Represents a conversation
+ *
+ * This class is not intended to be initialized directly.
+ */
 class Conversation {
     #client;
     #conversation;
     #lastMessage;
+    /**
+     * Creates a new conversation instance
+     *
+     * @param client - The client instance managing the conversation
+     * @param conversation - The underlying conversation instance
+     * @param lastMessage - Optional last message in the conversation
+     */
     constructor(client, conversation, lastMessage) {
         this.#client = client;
         this.#conversation = conversation;
@@ -241,21 +288,41 @@ class Conversation {
             ? new DecodedMessage(client, lastMessage)
             : undefined;
     }
+    /**
+     * Gets the unique identifier for this conversation
+     */
     get id() {
         return this.#conversation.id();
     }
+    /**
+     * Gets whether this conversation is currently active
+     */
     get isActive() {
         return this.#conversation.isActive();
     }
+    /**
+     * Gets the inbox ID that added this client's inbox to the conversation
+     */
     get addedByInboxId() {
         return this.#conversation.addedByInboxId();
     }
+    /**
+     * Gets the timestamp when the conversation was created in nanoseconds
+     */
     get createdAtNs() {
         return this.#conversation.createdAtNs();
     }
+    /**
+     * Gets the date when the conversation was created
+     */
     get createdAt() {
         return nsToDate(this.createdAtNs);
     }
+    /**
+     * Gets the metadata for this conversation
+     *
+     * @returns Promise that resolves with the conversation metadata
+     */
     async metadata() {
         const metadata = await this.#conversation.groupMetadata();
         return {
@@ -263,12 +330,28 @@ class Conversation {
             conversationType: metadata.conversationType(),
         };
     }
+    /**
+     * Gets the members of this conversation
+     *
+     * @returns Promise that resolves with the conversation members
+     */
     async members() {
         return this.#conversation.listMembers();
     }
+    /**
+     * Synchronizes conversation data from the network
+     *
+     * @returns Promise that resolves when synchronization is complete
+     */
     async sync() {
         return this.#conversation.sync();
     }
+    /**
+     * Creates a stream for new messages in this conversation
+     *
+     * @param callback - Optional callback function for handling new stream values
+     * @returns Stream instance for new messages
+     */
     stream(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversation.stream((error, value) => {
@@ -288,9 +371,22 @@ class Conversation {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Publishes pending messages that were sent optimistically
+     *
+     * @returns Promise that resolves when publishing is complete
+     */
     async publishMessages() {
         return this.#conversation.publishMessages();
     }
+    /**
+     * Prepares a message to be published
+     *
+     * @param content - The content to send
+     * @param contentType - Optional content type of the message content
+     * @returns Promise that resolves with the message ID
+     * @throws {MissingContentTypeError} if content type is required but not provided
+     */
     sendOptimistic(content, contentType) {
         if (typeof content !== "string" && !contentType) {
             throw new MissingContentTypeError();
@@ -301,6 +397,14 @@ class Conversation {
                 this.#client.encodeContent(content, contentType);
         return this.#conversation.sendOptimistic(encodedContent);
     }
+    /**
+     * Publishes a new message
+     *
+     * @param content - The content to send
+     * @param contentType - Optional content type of the message content
+     * @returns Promise that resolves with the message ID after it has been sent
+     * @throws {MissingContentTypeError} if content type is required but not provided
+     */
     async send(content, contentType) {
         if (typeof content !== "string" && !contentType) {
             throw new MissingContentTypeError();
@@ -311,80 +415,179 @@ class Conversation {
                 this.#client.encodeContent(content, contentType);
         return this.#conversation.send(encodedContent);
     }
+    /**
+     * Lists messages in this conversation
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Promise that resolves with an array of decoded messages
+     */
     async messages(options) {
         const messages = await this.#conversation.findMessages(options);
-        return (messages
-            .map((message) => new DecodedMessage(this.#client, message))
-            // filter out messages without content
-            .filter((message) => message.content !== undefined));
+        return messages.map((message) => new DecodedMessage(this.#client, message));
     }
+    /**
+     * Gets the last message in this conversation
+     *
+     * @returns Promise that resolves with the last message or undefined if none exists
+     */
     async lastMessage() {
         return this.#lastMessage ?? (await this.messages({ limit: 1 }))[0];
     }
+    /**
+     * Gets the consent state for this conversation
+     */
     get consentState() {
         return this.#conversation.consentState();
     }
+    /**
+     * Updates the consent state for this conversation
+     *
+     * @param consentState - The new consent state to set
+     */
     updateConsentState(consentState) {
         this.#conversation.updateConsentState(consentState);
     }
+    /**
+     * Gets the message disappearing settings for this conversation
+     *
+     * @returns The current message disappearing settings or undefined if not set
+     */
     messageDisappearingSettings() {
         return this.#conversation.messageDisappearingSettings() ?? undefined;
     }
+    /**
+     * Updates message disappearing settings for this conversation
+     *
+     * @param fromNs - The timestamp from which messages should start disappearing
+     * @param inNs - The duration after which messages should disappear
+     * @returns Promise that resolves when the update is complete
+     */
     async updateMessageDisappearingSettings(fromNs, inNs) {
         return this.#conversation.updateMessageDisappearingSettings({
             fromNs,
             inNs,
         });
     }
+    /**
+     * Removes message disappearing settings from this conversation
+     *
+     * @returns Promise that resolves when the settings are removed
+     */
     async removeMessageDisappearingSettings() {
         return this.#conversation.removeMessageDisappearingSettings();
     }
+    /**
+     * Checks if message disappearing is enabled for this conversation
+     *
+     * @returns Whether message disappearing is enabled
+     */
     isMessageDisappearingEnabled() {
         return this.#conversation.isMessageDisappearingEnabled();
     }
     pausedForVersion() {
         return this.#conversation.pausedForVersion() ?? undefined;
     }
+    /**
+     * Retrieves HMAC keys for this conversation
+     *
+     * @returns The HMAC keys for this conversation
+     */
     getHmacKeys() {
         return this.#conversation.getHmacKeys();
     }
 }
 
+/**
+ * Represents a direct message conversation between two inboxes
+ *
+ * This class is not intended to be initialized directly.
+ */
 class Dm extends Conversation {
     #conversation;
+    /**
+     * Creates a new direct message conversation instance
+     *
+     * @param client - The client instance managing this direct message conversation
+     * @param conversation - The underlying conversation instance
+     * @param lastMessage - Optional last message in the conversation
+     */
     constructor(client, conversation, lastMessage) {
         super(client, conversation, lastMessage);
         this.#conversation = conversation;
     }
+    /**
+     * Retrieves the inbox ID of the other participant in the DM
+     *
+     * @returns Promise that resolves with the peer's inbox ID
+     */
     get peerInboxId() {
         return this.#conversation.dmPeerInboxId();
     }
 }
 
+/**
+ * Represents a group conversation between multiple inboxes
+ *
+ * This class is not intended to be initialized directly.
+ */
 class Group extends Conversation {
     #conversation;
+    /**
+     * Creates a new group conversation instance
+     *
+     * @param client - The client instance managing this group conversation
+     * @param conversation - The underlying conversation object
+     * @param lastMessage - Optional last message in the conversation
+     */
     constructor(client, conversation, lastMessage) {
         super(client, conversation, lastMessage);
         this.#conversation = conversation;
     }
+    /**
+     * The name of the group
+     */
     get name() {
         return this.#conversation.groupName();
     }
+    /**
+     * Updates the group's name
+     *
+     * @param name The new name for the group
+     */
     async updateName(name) {
         return this.#conversation.updateGroupName(name);
     }
+    /**
+     * The image URL of the group
+     */
     get imageUrl() {
         return this.#conversation.groupImageUrlSquare();
     }
+    /**
+     * Updates the group's image URL
+     *
+     * @param imageUrl The new image URL for the group
+     */
     async updateImageUrl(imageUrl) {
         return this.#conversation.updateGroupImageUrlSquare(imageUrl);
     }
+    /**
+     * The description of the group
+     */
     get description() {
         return this.#conversation.groupDescription();
     }
+    /**
+     * Updates the group's description
+     *
+     * @param description The new description for the group
+     */
     async updateDescription(description) {
         return this.#conversation.updateGroupDescription(description);
     }
+    /**
+     * The permissions of the group
+     */
     get permissions() {
         const permissions = this.#conversation.groupPermissions();
         return {
@@ -392,54 +595,136 @@ class Group extends Conversation {
             policySet: permissions.policySet(),
         };
     }
+    /**
+     * Updates a specific permission policy for the group
+     *
+     * @param permissionType The type of permission to update
+     * @param policy The new permission policy
+     * @param metadataField Optional metadata field for the permission
+     */
     async updatePermission(permissionType, policy, metadataField) {
         return this.#conversation.updatePermissionPolicy(permissionType, policy, metadataField);
     }
+    /**
+     * The list of admins of the group
+     */
     get admins() {
         return this.#conversation.adminList();
     }
+    /**
+     * The list of super admins of the group
+     */
     get superAdmins() {
         return this.#conversation.superAdminList();
     }
+    /**
+     * Checks if an inbox is an admin of the group
+     *
+     * @param inboxId The inbox ID to check
+     * @returns Boolean indicating if the inbox is an admin
+     */
     isAdmin(inboxId) {
         return this.#conversation.isAdmin(inboxId);
     }
+    /**
+     * Checks if an inbox is a super admin of the group
+     *
+     * @param inboxId The inbox ID to check
+     * @returns Boolean indicating if the inbox is a super admin
+     */
     isSuperAdmin(inboxId) {
         return this.#conversation.isSuperAdmin(inboxId);
     }
+    /**
+     * Adds members to the group using identifiers
+     *
+     * @param identifiers Array of member identifiers to add
+     */
     async addMembersByIdentifiers(identifiers) {
         return this.#conversation.addMembers(identifiers);
     }
+    /**
+     * Adds members to the group using inbox IDs
+     *
+     * @param inboxIds Array of inbox IDs to add
+     */
     async addMembers(inboxIds) {
         return this.#conversation.addMembersByInboxId(inboxIds);
     }
+    /**
+     * Removes members from the group using identifiers
+     *
+     * @param identifiers Array of member identifiers to remove
+     */
     async removeMembersByIdentifiers(identifiers) {
         return this.#conversation.removeMembers(identifiers);
     }
+    /**
+     * Removes members from the group using inbox IDs
+     *
+     * @param inboxIds Array of inbox IDs to remove
+     */
     async removeMembers(inboxIds) {
         return this.#conversation.removeMembersByInboxId(inboxIds);
     }
+    /**
+     * Promotes a group member to admin status
+     *
+     * @param inboxId The inbox ID of the member to promote
+     */
     async addAdmin(inboxId) {
         return this.#conversation.addAdmin(inboxId);
     }
+    /**
+     * Removes admin status from a group member
+     *
+     * @param inboxId The inbox ID of the admin to demote
+     */
     async removeAdmin(inboxId) {
         return this.#conversation.removeAdmin(inboxId);
     }
+    /**
+     * Promotes a group member to super admin status
+     *
+     * @param inboxId The inbox ID of the member to promote
+     */
     async addSuperAdmin(inboxId) {
         return this.#conversation.addSuperAdmin(inboxId);
     }
+    /**
+     * Removes super admin status from a group member
+     *
+     * @param inboxId The inbox ID of the super admin to demote
+     */
     async removeSuperAdmin(inboxId) {
         return this.#conversation.removeSuperAdmin(inboxId);
     }
 }
 
+/**
+ * Manages conversations
+ *
+ * This class is not intended to be initialized directly.
+ */
 class Conversations {
     #client;
     #conversations;
+    /**
+     * Creates a new conversations instance
+     *
+     * @param client - The client instance managing the conversations
+     * @param conversations - The underlying conversations instance
+     */
     constructor(client, conversations) {
         this.#client = client;
         this.#conversations = conversations;
     }
+    /**
+     * Retrieves a conversation by its ID
+     *
+     * @param id - The conversation ID to look up
+     * @returns The conversation if found, undefined otherwise
+     */
     async getConversationById(id) {
         try {
             // findGroupById will throw if group is not found
@@ -453,6 +738,12 @@ class Conversations {
             return undefined;
         }
     }
+    /**
+     * Retrieves a DM by inbox ID
+     *
+     * @param inboxId - The inbox ID to look up
+     * @returns The DM if found, undefined otherwise
+     */
     getDmByInboxId(inboxId) {
         try {
             // findDmByTargetInboxId will throw if group is not found
@@ -463,6 +754,12 @@ class Conversations {
             return undefined;
         }
     }
+    /**
+     * Retrieves a message by its ID
+     *
+     * @param id - The message ID to look up
+     * @returns The decoded message if found, undefined otherwise
+     */
     getMessageById(id) {
         try {
             // findMessageById will throw if message is not found
@@ -473,26 +770,60 @@ class Conversations {
             return undefined;
         }
     }
+    /**
+     * Creates a new group conversation with the specified identifiers
+     *
+     * @param identifiers - Array of identifiers for group members
+     * @param options - Optional group creation options
+     * @returns The new group
+     */
     async newGroupWithIdentifiers(identifiers, options) {
         const group = await this.#conversations.createGroup(identifiers, options);
         const conversation = new Group(this.#client, group);
         return conversation;
     }
+    /**
+     * Creates a new group conversation with the specified inbox IDs
+     *
+     * @param inboxIds - Array of inbox IDs for group members
+     * @param options - Optional group creation options
+     * @returns The new group
+     */
     async newGroup(inboxIds, options) {
         const group = await this.#conversations.createGroupByInboxId(inboxIds, options);
         const conversation = new Group(this.#client, group);
         return conversation;
     }
+    /**
+     * Creates a new DM conversation with the specified identifier
+     *
+     * @param identifier - Identifier for the DM recipient
+     * @param options - Optional DM creation options
+     * @returns The new DM
+     */
     async newDmWithIdentifier(identifier, options) {
         const group = await this.#conversations.createDm(identifier, options);
         const conversation = new Dm(this.#client, group);
         return conversation;
     }
+    /**
+     * Creates a new DM conversation with the specified inbox ID
+     *
+     * @param inboxId - Inbox ID for the DM recipient
+     * @param options - Optional DM creation options
+     * @returns The new DM
+     */
     async newDm(inboxId, options) {
         const group = await this.#conversations.createDmByInboxId(inboxId, options);
         const conversation = new Dm(this.#client, group);
         return conversation;
     }
+    /**
+     * Lists all conversations with optional filtering
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Array of conversations
+     */
     async list(options) {
         const groups = this.#conversations.list(options);
         return Promise.all(groups.map(async (item) => {
@@ -502,6 +833,12 @@ class Conversations {
                 : new Group(this.#client, item.conversation, item.lastMessage);
         }));
     }
+    /**
+     * Lists all groups with optional filtering
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Array of groups
+     */
     listGroups(options) {
         const groups = this.#conversations.listGroups(options);
         return groups.map((item) => {
@@ -509,6 +846,12 @@ class Conversations {
             return conversation;
         });
     }
+    /**
+     * Lists all DMs with optional filtering
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Array of DMs
+     */
     listDms(options) {
         const groups = this.#conversations.listDms(options);
         return groups.map((item) => {
@@ -516,12 +859,30 @@ class Conversations {
             return conversation;
         });
     }
+    /**
+     * Synchronizes conversations for the current client from the network
+     *
+     * @returns Promise that resolves when sync is complete
+     */
     async sync() {
         return this.#conversations.sync();
     }
+    /**
+     * Synchronizes all conversations and messages from the network with optional
+     * consent state filtering
+     *
+     * @param consentStates - Optional array of consent states to filter by
+     * @returns Promise that resolves when sync is complete
+     */
     async syncAll(consentStates) {
         return this.#conversations.syncAllConversations(consentStates);
     }
+    /**
+     * Creates a stream for new conversations
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new conversations
+     */
     stream(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversations.stream((err, value) => {
@@ -547,6 +908,12 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream for new group conversations
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new group conversations
+     */
     streamGroups(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversations.streamGroups((error, value) => {
@@ -566,6 +933,12 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream for new DM conversations
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new DM conversations
+     */
     streamDms(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversations.streamDms((error, value) => {
@@ -585,6 +958,12 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream for all new messages
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new messages
+     */
     async streamAllMessages(callback) {
         // sync conversations first
         await this.sync();
@@ -606,6 +985,12 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream for all new group messages
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new group messages
+     */
     async streamAllGroupMessages(callback) {
         // sync conversations first
         await this.sync();
@@ -627,6 +1012,12 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream for all new DM messages
+     *
+     * @param callback - Optional callback function for handling new stream value
+     * @returns Stream instance for new DM messages
+     */
     async streamAllDmMessages(callback) {
         // sync conversations first
         await this.sync();
@@ -648,33 +1039,87 @@ class Conversations {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Retrieves HMAC keys for all conversations
+     *
+     * @returns The HMAC keys for all conversations
+     */
     hmacKeys() {
         return this.#conversations.getHmacKeys();
     }
 }
 
+/**
+ * Manages user preferences and consent states
+ *
+ * This class is not intended to be initialized directly.
+ */
 class Preferences {
     #client;
     #conversations;
+    /**
+     * Creates a new preferences instance
+     *
+     * @param client - The client instance managing preferences
+     * @param conversations - The underlying conversations instance
+     */
     constructor(client, conversations) {
         this.#client = client;
         this.#conversations = conversations;
     }
+    /**
+     * Retrieves the current inbox state
+     *
+     * @param refreshFromNetwork - Optional flag to force refresh from network
+     * @returns Promise that resolves with the inbox state
+     */
     async inboxState(refreshFromNetwork = false) {
         return this.#client.inboxState(refreshFromNetwork);
     }
+    /**
+     * Gets the latest inbox state for a specific inbox
+     *
+     * @param inboxId - The inbox ID to get state for
+     * @returns Promise that resolves with the latest inbox state
+     */
     async getLatestInboxState(inboxId) {
         return this.#client.getLatestInboxState(inboxId);
     }
+    /**
+     * Retrieves inbox state for specific inbox IDs
+     *
+     * @param inboxIds - Array of inbox IDs to get state for
+     * @param refreshFromNetwork - Optional flag to force refresh from network
+     * @returns Promise that resolves with the inbox state for the inbox IDs
+     */
     async inboxStateFromInboxIds(inboxIds, refreshFromNetwork) {
         return this.#client.addressesFromInboxId(refreshFromNetwork ?? false, inboxIds);
     }
+    /**
+     * Updates consent states for multiple records
+     *
+     * @param consentStates - Array of consent records to update
+     * @returns Promise that resolves when consent states are updated
+     */
     async setConsentStates(consentStates) {
         return this.#client.setConsentStates(consentStates);
     }
+    /**
+     * Retrieves consent state for a specific entity
+     *
+     * @param entityType - Type of entity to get consent for
+     * @param entity - Entity identifier
+     * @returns Promise that resolves with the consent state
+     */
     async getConsentState(entityType, entity) {
         return this.#client.getConsentState(entityType, entity);
     }
+    /**
+     * Creates a stream of consent state updates
+     *
+     * @param callback - Optional callback function for handling stream updates
+     * @returns Stream instance for consent updates
+     */
     streamConsent(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversations.streamConsent((err, value) => {
@@ -689,6 +1134,12 @@ class Preferences {
         asyncStream.onReturn = stream.end.bind(stream);
         return asyncStream;
     }
+    /**
+     * Creates a stream of user preference updates
+     *
+     * @param callback - Optional callback function for handling stream updates
+     * @returns Stream instance for preference updates
+     */
     streamPreferences(callback) {
         const asyncStream = new AsyncStream();
         const stream = this.#conversations.streamPreferences((err, value) => {
@@ -715,81 +1166,202 @@ const getInboxIdForIdentifier = async (identifier, env = "dev") => {
     return getInboxIdForIdentifier$1(host, isSecure, identifier);
 };
 
-const createClient = async (identifier, encryptionKey, options) => {
+const createClient = async (identifier, options) => {
     const env = options?.env || "dev";
     const host = options?.apiUrl || ApiUrls[env];
     const isSecure = host.startsWith("https");
     const inboxId = (await getInboxIdForIdentifier(identifier, env)) ||
         generateInboxId(identifier);
-    const dbPath = options?.dbPath || join(process.cwd(), `xmtp-${env}-${inboxId}.db3`);
+    const dbPath = options?.dbPath === undefined
+        ? join(process.cwd(), `xmtp-${env}-${inboxId}.db3`)
+        : options.dbPath;
     const logOptions = {
         structured: options?.structuredLogging ?? false,
         level: options?.loggingLevel ?? "off" /* LogLevel.off */,
     };
     const historySyncUrl = options?.historySyncUrl || HistorySyncUrls[env];
-    return createClient$1(host, isSecure, dbPath, inboxId, identifier, encryptionKey, historySyncUrl, logOptions);
+    return createClient$1(host, isSecure, dbPath, inboxId, identifier, options?.dbEncryptionKey, historySyncUrl, logOptions);
 };
 
 const version = `${bindingsVersion.branch}@${bindingsVersion.version} (${bindingsVersion.date})`;
 
+/**
+ * Client for interacting with the XMTP network
+ */
 class Client {
-    #innerClient;
+    #client;
     #conversations;
     #preferences;
     #signer;
     #codecs;
-    constructor(client, signer, codecs) {
-        this.#innerClient = client;
-        const conversations = client.conversations();
-        this.#conversations = new Conversations(this, conversations);
-        this.#preferences = new Preferences(client, conversations);
-        this.#signer = signer;
-        this.#codecs = new Map(codecs.map((codec) => [codec.contentType.toString(), codec]));
-    }
-    static async create(signer, encryptionKey, options) {
-        const identifier = await signer.getIdentifier();
-        const client = await createClient(identifier, encryptionKey, options);
-        const clientInstance = new Client(client, signer, [
+    #identifier;
+    #options;
+    /**
+     * Creates a new XMTP client instance
+     *
+     * This class is not intended to be initialized directly.
+     * Use `Client.create` or `Client.build` instead.
+     *
+     * @param options - Optional configuration for the client
+     */
+    constructor(options) {
+        this.#options = options;
+        const codecs = [
             new GroupUpdatedCodec(),
             new TextCodec(),
             ...(options?.codecs ?? []),
-        ]);
+        ];
+        this.#codecs = new Map(codecs.map((codec) => [codec.contentType.toString(), codec]));
+    }
+    /**
+     * Initializes the client with the provided identifier
+     *
+     * This is not meant to be called directly.
+     * Use `Client.create` or `Client.build` instead.
+     *
+     * @param identifier - The identifier to initialize the client with
+     */
+    async init(identifier) {
+        if (this.#client) {
+            return;
+        }
+        this.#identifier = identifier;
+        this.#client = await createClient(identifier, this.#options);
+        const conversations = this.#client.conversations();
+        this.#conversations = new Conversations(this, conversations);
+        this.#preferences = new Preferences(this.#client, conversations);
+    }
+    /**
+     * Creates a new client instance with a signer
+     *
+     * @param signer - The signer to use for authentication
+     * @param options - Optional configuration for the client
+     * @returns A new client instance
+     */
+    static async create(signer, options) {
+        const identifier = await signer.getIdentifier();
+        const client = new Client(options);
+        client.#signer = signer;
+        await client.init(identifier);
         if (!options?.disableAutoRegister) {
-            await clientInstance.register();
+            await client.register();
         }
-        return clientInstance;
+        return client;
     }
-    get identifier() {
-        return this.#innerClient.accountIdentifier;
+    /**
+     * Creates a new client instance with an identifier
+     *
+     * Clients created with this method must already be registered.
+     * Any methods called that require a signer will throw an error.
+     *
+     * @param identifier - The identifier to use
+     * @param options - Optional configuration for the client
+     * @returns A new client instance
+     */
+    static async build(identifier, options) {
+        const client = new Client({
+            ...options,
+            disableAutoRegister: true,
+        });
+        await client.init(identifier);
+        return client;
+    }
+    /**
+     * Gets the client options
+     */
+    get options() {
+        return this.#options;
+    }
+    /**
+     * Gets the signer associated with this client
+     */
+    get signer() {
+        return this.#signer;
+    }
+    /**
+     * Gets the account identifier for this client
+     */
+    get accountIdentifier() {
+        return this.#identifier;
     }
+    /**
+     * Gets the inbox ID associated with this client
+     */
     get inboxId() {
-        return this.#innerClient.inboxId();
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.inboxId();
     }
+    /**
+     * Gets the installation ID for this client
+     */
     get installationId() {
-        return this.#innerClient.installationId();
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.installationId();
     }
+    /**
+     * Gets the installation ID bytes for this client
+     */
     get installationIdBytes() {
-        return this.#innerClient.installationIdBytes();
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.installationIdBytes();
     }
+    /**
+     * Gets whether the client is registered with the XMTP network
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     get isRegistered() {
-        return this.#innerClient.isRegistered();
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.isRegistered();
     }
+    /**
+     * Gets the conversations manager for this client
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     get conversations() {
+        if (!this.#conversations) {
+            throw new ClientNotInitializedError();
+        }
         return this.#conversations;
     }
+    /**
+     * Gets the preferences manager for this client
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     get preferences() {
+        if (!this.#preferences) {
+            throw new ClientNotInitializedError();
+        }
         return this.#preferences;
     }
     /**
+     * Creates signature text for creating a new inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `register` function instead.
+     * It is highly recommended to use the `register` method instead.
+     *
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_createInboxSignatureText() {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            const signatureText = await this.#innerClient.createInboxSignatureText();
+            const signatureText = await this.#client.createInboxSignatureText();
             return signatureText;
         }
         catch {
@@ -797,21 +1369,31 @@ class Client {
         }
     }
     /**
+     * Creates signature text for adding a new account to the client's inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `unsafe_addAccount` function instead.
+     * It is highly recommended to use the `unsafe_addAccount` method instead.
      *
      * The `allowInboxReassign` parameter must be true or this function will
      * throw an error.
+     *
+     * @param newAccountIdentifier - The identifier of the new account
+     * @param allowInboxReassign - Whether to allow inbox reassignment
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_addAccountSignatureText(newAccountIdentifier, allowInboxReassign = false) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         if (!allowInboxReassign) {
             throw new InboxReassignError();
         }
         try {
-            const signatureText = await this.#innerClient.addIdentifierSignatureText(newAccountIdentifier);
+            const signatureText = await this.#client.addIdentifierSignatureText(newAccountIdentifier);
             return signatureText;
         }
         catch {
@@ -819,15 +1401,24 @@ class Client {
         }
     }
     /**
+     * Creates signature text for removing an account from the client's inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `removeAccount` function instead.
+     * It is highly recommended to use the `removeAccount` method instead.
+     *
+     * @param identifier - The identifier of the account to remove
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_removeAccountSignatureText(identifier) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            const signatureText = await this.#innerClient.revokeIdentifierSignatureText(identifier);
+            const signatureText = await this.#client.revokeIdentifierSignatureText(identifier);
             return signatureText;
         }
         catch {
@@ -835,16 +1426,24 @@ class Client {
         }
     }
     /**
+     * Creates signature text for revoking all other installations of the
+     * client's inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `revokeAllOtherInstallations` function
-     * instead.
+     * It is highly recommended to use the `revokeAllOtherInstallations` method instead.
+     *
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_revokeAllOtherInstallationsSignatureText() {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            const signatureText = await this.#innerClient.revokeAllOtherInstallationsSignatureText();
+            const signatureText = await this.#client.revokeAllOtherInstallationsSignatureText();
             return signatureText;
         }
         catch {
@@ -852,15 +1451,25 @@ class Client {
         }
     }
     /**
+     * Creates signature text for revoking specific installations of the
+     * client's inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `revokeInstallations` function instead.
+     * It is highly recommended to use the `revokeInstallations` method instead.
+     *
+     * @param installationIds - The installation IDs to revoke
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_revokeInstallationsSignatureText(installationIds) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            const signatureText = await this.#innerClient.revokeInstallationsSignatureText(installationIds);
+            const signatureText = await this.#client.revokeInstallationsSignatureText(installationIds);
             return signatureText;
         }
         catch {
@@ -868,15 +1477,25 @@ class Client {
         }
     }
     /**
+     * Creates signature text for changing the recovery identifier for this
+     * client's inbox
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
-     * It is highly recommended to use the `changeRecoveryIdentifer` function instead.
+     * It is highly recommended to use the `changeRecoveryIdentifier` method instead.
+     *
+     * @param identifier - The new recovery identifier
+     * @returns The signature text
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_changeRecoveryIdentifierSignatureText(identifier) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            const signatureText = await this.#innerClient.changeRecoveryIdentifierSignatureText(identifier);
+            const signatureText = await this.#client.changeRecoveryIdentifierSignatureText(identifier);
             return signatureText;
         }
         catch {
@@ -884,54 +1503,99 @@ class Client {
         }
     }
     /**
+     * Adds a signature for a specific request type
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
      * It is highly recommended to use the `register`, `unsafe_addAccount`,
      * `removeAccount`, `revokeAllOtherInstallations`, or `revokeInstallations`
-     * functions instead.
+     * methods instead.
+     *
+     * @param signatureType - The type of signature request
+     * @param signatureText - The text to sign
+     * @param signer - The signer to use
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_addSignature(signatureType, signatureText, signer) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         switch (signer.type) {
             case "SCW":
-                await this.#innerClient.addScwSignature(signatureType, await signer.signMessage(signatureText), signer.getChainId(), signer.getBlockNumber?.());
+                await this.#client.addScwSignature(signatureType, await signer.signMessage(signatureText), signer.getChainId(), signer.getBlockNumber?.());
                 break;
             case "EOA":
-                await this.#innerClient.addEcdsaSignature(signatureType, await signer.signMessage(signatureText));
+                await this.#client.addEcdsaSignature(signatureType, await signer.signMessage(signatureText));
                 break;
         }
     }
     /**
+     * Applies all pending signatures
+     *
      * WARNING: This function should be used with caution. It is only provided
      * for use in special cases where the provided workflows do not meet the
      * requirements of an application.
      *
      * It is highly recommended to use the `register`, `unsafe_addAccount`,
      * `removeAccount`, `revokeAllOtherInstallations`, or `revokeInstallations`
-     * functions instead.
+     * methods instead.
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
      */
     async unsafe_applySignatures() {
-        return this.#innerClient.applySignatureRequests();
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.applySignatureRequests();
     }
+    /**
+     * Registers the client with the XMTP network
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {SignerUnavailableError} if no signer is available
+     */
     async register() {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        if (!this.#signer) {
+            throw new SignerUnavailableError();
+        }
         const signatureText = await this.unsafe_createInboxSignatureText();
         // if the signature text is not available, the client is already registered
         if (!signatureText) {
             return;
         }
         await this.unsafe_addSignature(1 /* SignatureRequestType.CreateInbox */, signatureText, this.#signer);
-        return this.#innerClient.registerIdentity();
+        return this.#client.registerIdentity();
     }
     /**
+     * Adds a new account to the client inbox
+     *
      * WARNING: This function should be used with caution. Adding a wallet already
-     * associated with an inboxId will cause the wallet to lose access to
+     * associated with an inbox ID will cause the wallet to lose access to
      * that inbox.
      *
      * The `allowInboxReassign` parameter must be true to reassign an inbox
      * already associated with a different account.
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @param newAccountSigner - The signer for the new account
+     * @param allowInboxReassign - Whether to allow inbox reassignment
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {AccountAlreadyAssociatedError} if the account is already associated with an inbox ID
+     * @throws {GenerateSignatureError} if the signature cannot be generated
+     * @throws {SignerUnavailableError} if no signer is available
      */
     async unsafe_addAccount(newAccountSigner, allowInboxReassign = false) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         // check for existing inbox id
         const identifier = await newAccountSigner.getIdentifier();
         const existingInboxId = await this.getInboxIdByIdentifier(identifier);
@@ -945,7 +1609,23 @@ class Client {
         await this.unsafe_addSignature(0 /* SignatureRequestType.AddWallet */, signatureText, newAccountSigner);
         await this.unsafe_applySignatures();
     }
+    /**
+     * Removes an account from the client's inbox
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @param identifier - The identifier of the account to remove
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {GenerateSignatureError} if the signature cannot be generated
+     * @throws {SignerUnavailableError} if no signer is available
+     */
     async removeAccount(identifier) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        if (!this.#signer) {
+            throw new SignerUnavailableError();
+        }
         const signatureText = await this.unsafe_removeAccountSignatureText(identifier);
         if (!signatureText) {
             throw new GenerateSignatureError(2 /* SignatureRequestType.RevokeWallet */);
@@ -953,7 +1633,22 @@ class Client {
         await this.unsafe_addSignature(2 /* SignatureRequestType.RevokeWallet */, signatureText, this.#signer);
         await this.unsafe_applySignatures();
     }
+    /**
+     * Revokes all other installations of the client's inbox
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {GenerateSignatureError} if the signature cannot be generated
+     * @throws {SignerUnavailableError} if no signer is available
+     */
     async revokeAllOtherInstallations() {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        if (!this.#signer) {
+            throw new SignerUnavailableError();
+        }
         const signatureText = await this.unsafe_revokeAllOtherInstallationsSignatureText();
         if (!signatureText) {
             throw new GenerateSignatureError(3 /* SignatureRequestType.RevokeInstallations */);
@@ -961,7 +1656,23 @@ class Client {
         await this.unsafe_addSignature(3 /* SignatureRequestType.RevokeInstallations */, signatureText, this.#signer);
         await this.unsafe_applySignatures();
     }
+    /**
+     * Revokes specific installations of the client's inbox
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @param installationIds - The installation IDs to revoke
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {SignerUnavailableError} if no signer is available
+     * @throws {GenerateSignatureError} if the signature cannot be generated
+     */
     async revokeInstallations(installationIds) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        if (!this.#signer) {
+            throw new SignerUnavailableError();
+        }
         const signatureText = await this.unsafe_revokeInstallationsSignatureText(installationIds);
         if (!signatureText) {
             throw new GenerateSignatureError(3 /* SignatureRequestType.RevokeInstallations */);
@@ -969,7 +1680,23 @@ class Client {
         await this.unsafe_addSignature(3 /* SignatureRequestType.RevokeInstallations */, signatureText, this.#signer);
         await this.unsafe_applySignatures();
     }
+    /**
+     * Changes the recovery identifier for the client's inbox
+     *
+     * Requires a signer, use `Client.create` to create a client with a signer.
+     *
+     * @param identifier - The new recovery identifier
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     * @throws {SignerUnavailableError} if no signer is available
+     * @throws {GenerateSignatureError} if the signature cannot be generated
+     */
     async changeRecoveryIdentifier(identifier) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        if (!this.#signer) {
+            throw new SignerUnavailableError();
+        }
         const signatureText = await this.unsafe_changeRecoveryIdentifierSignatureText(identifier);
         if (!signatureText) {
             throw new GenerateSignatureError(4 /* SignatureRequestType.ChangeRecoveryIdentifier */);
@@ -977,10 +1704,27 @@ class Client {
         await this.unsafe_addSignature(4 /* SignatureRequestType.ChangeRecoveryIdentifier */, signatureText, this.#signer);
         await this.unsafe_applySignatures();
     }
+    /**
+     * Checks if the client can message the specified identifiers
+     *
+     * @param identifiers - The identifiers to check
+     * @returns Whether the client can message the identifiers
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     async canMessage(identifiers) {
-        const canMessage = await this.#innerClient.canMessage(identifiers);
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        const canMessage = await this.#client.canMessage(identifiers);
         return new Map(Object.entries(canMessage));
     }
+    /**
+     * Checks if the specified identifiers can be messaged
+     *
+     * @param identifiers - The identifiers to check
+     * @param env - Optional XMTP environment
+     * @returns Map of identifiers to whether they can be messaged
+     */
     static async canMessage(identifiers, env) {
         const canMessageMap = new Map();
         for (const identifier of identifiers) {
@@ -989,12 +1733,36 @@ class Client {
         }
         return canMessageMap;
     }
+    /**
+     * Gets the key package statuses for the specified installation IDs
+     *
+     * @param installationIds - The installation IDs to check
+     * @returns The key package statuses
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     async getKeyPackageStatusesForInstallationIds(installationIds) {
-        return this.#innerClient.getKeyPackageStatusesForInstallationIds(installationIds);
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.getKeyPackageStatusesForInstallationIds(installationIds);
     }
+    /**
+     * Gets the codec for a given content type
+     *
+     * @param contentType - The content type to get the codec for
+     * @returns The codec, if found
+     */
     codecFor(contentType) {
         return this.#codecs.get(contentType.toString());
     }
+    /**
+     * Encodes content for a given content type
+     *
+     * @param content - The content to encode
+     * @param contentType - The content type to encode for
+     * @returns The encoded content
+     * @throws {CodecNotFoundError} if no codec is found for the content type
+     */
     encodeContent(content, contentType) {
         const codec = this.codecFor(contentType);
         if (!codec) {
@@ -1007,6 +1775,15 @@ class Client {
         }
         return encoded;
     }
+    /**
+     * Decodes a message for a given content type
+     *
+     * @param message - The message to decode
+     * @param contentType - The content type to decode for
+     * @returns The decoded content
+     * @throws {CodecNotFoundError} if no codec is found for the content type
+     * @throws {InvalidGroupMembershipChangeError} if the message is an invalid group membership change
+     */
     decodeContent(message, contentType) {
         const codec = this.codecFor(contentType);
         if (!codec) {
@@ -1017,27 +1794,62 @@ class Client {
             message.kind !== 1 /* GroupMessageKind.MembershipChange */) {
             throw new InvalidGroupMembershipChangeError(message.id);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return codec.decode(message.content, this);
     }
-    async requestHistorySync() {
-        return this.#innerClient.sendHistorySyncRequest();
-    }
+    /**
+     * Finds the inbox ID for a given identifier
+     *
+     * @param identifier - The identifier to look up
+     * @returns The inbox ID, if found
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     async getInboxIdByIdentifier(identifier) {
-        return this.#innerClient.findInboxIdByIdentifier(identifier);
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.findInboxIdByIdentifier(identifier);
     }
+    /**
+     * Signs a message with the installation key
+     *
+     * @param signatureText - The text to sign
+     * @returns The signature
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     signWithInstallationKey(signatureText) {
-        return this.#innerClient.signWithInstallationKey(signatureText);
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
+        return this.#client.signWithInstallationKey(signatureText);
     }
+    /**
+     * Verifies a signature was made with the installation key
+     *
+     * @param signatureText - The text that was signed
+     * @param signatureBytes - The signature bytes to verify
+     * @returns Whether the signature is valid
+     * @throws {ClientNotInitializedError} if the client is not initialized
+     */
     verifySignedWithInstallationKey(signatureText, signatureBytes) {
+        if (!this.#client) {
+            throw new ClientNotInitializedError();
+        }
         try {
-            this.#innerClient.verifySignedWithInstallationKey(signatureText, signatureBytes);
+            this.#client.verifySignedWithInstallationKey(signatureText, signatureBytes);
             return true;
         }
         catch {
             return false;
         }
     }
+    /**
+     * Verifies a signature was made with a public key
+     *
+     * @param signatureText - The text that was signed
+     * @param signatureBytes - The signature bytes to verify
+     * @param publicKey - The public key to verify against
+     * @returns Whether the signature is valid
+     */
     static verifySignedWithPublicKey(signatureText, signatureBytes, publicKey) {
         try {
             verifySignedWithPublicKey(signatureText, signatureBytes, publicKey);
@@ -1047,14 +1859,33 @@ class Client {
             return false;
         }
     }
+    /**
+     * Checks if an address is authorized for an inbox
+     *
+     * @param inboxId - The inbox ID to check
+     * @param address - The address to check
+     * @param options - Optional network options
+     * @returns Whether the address is authorized
+     */
     static async isAddressAuthorized(inboxId, address, options) {
         const host = options?.apiUrl || ApiUrls[options?.env || "dev"];
         return await isAddressAuthorized(host, inboxId, address);
     }
+    /**
+     * Checks if an installation is authorized for an inbox
+     *
+     * @param inboxId - The inbox ID to check
+     * @param installation - The installation to check
+     * @param options - Optional network options
+     * @returns Whether the installation is authorized
+     */
     static async isInstallationAuthorized(inboxId, installation, options) {
         const host = options?.apiUrl || ApiUrls[options?.env || "dev"];
         return await isInstallationAuthorized(host, inboxId, installation);
     }
+    /**
+     * Gets the version of the Node bindings
+     */
     static get version() {
         return version;
     }