Mesh SDK methods

on<T extends ProtocolEvent = ProtocolEvent>(eventType: EventType | "all", listener: EventListener<T>): this

off<T extends ProtocolEvent = ProtocolEvent>(eventType: EventType | "all", listener: EventListener<T>): this

once<T extends ProtocolEvent = ProtocolEvent>(eventType: EventType | "all", listener: EventListener<T>): this

removeAllListeners(eventType?: EventType | "all"): this

start(): Promise<void>

stop(): Promise<void>

emitTestEvent(): Promise<void>

sendMessage(params: SendMessageParams): Promise<string>

forwardMessage(params: ForwardMessageParams): Promise<string>

sendConnectionRequest(params: SendConnectionRequestParams): Promise<string>

acceptConnectionRequest(params: AcceptConnectionRequestParams): Promise<string>

rejectConnectionRequest(params: RejectConnectionRequestParams): Promise<string>

cancelConnectionRequest(params: CancelConnectionRequestParams): Promise<string>

getActiveTransports(): Promise<TransportType[]>

enableTransport(type: TransportType, config?: InternetTransportConfig | WifiDirectTransportConfig | NostrTransportConfig | ReticulumTransportConfig): Promise<void>

disableTransport(type: TransportType): Promise<void>

isBluetoothEnabled(): Promise<boolean>

requestEnableBluetooth(): Promise<boolean>

getTopology(): Promise<NetworkTopology>

getMessageStats(): Promise<MessageDeliveryStats[]>

getDeliverySuccessRate(): Promise<number>

getMedianLatency(): Promise<number | null>

getMedianHops(): Promise<number | null>

sendMedia(params: SendMediaParams): Promise<string>

sendFile(params: SendFileParams): Promise<string>

sendImage(recipient: string, fileData: string, fileName: string, metadata?: MediaMetadata): Promise<string>

sendVoiceNote(recipient: string, fileData: string, fileName: string, metadata?: MediaMetadata): Promise<string>

sendVideoNote(recipient: string, fileData: string, fileName: string, metadata?: MediaMetadata): Promise<string>

sendVideo(recipient: string, fileData: string, fileName: string, metadata?: MediaMetadata): Promise<string>

getFileProgress(fileId: string): Promise<FileProgress | null>

cancelFileTransfer(fileId: string): Promise<boolean>

receiveMessage(): Promise<MessageReceivedEvent | null>

pause(): Promise<void>

resume(): Promise<void>

getState(): Promise<ProtocolState>

setBatteryLevel(level: number): Promise<void>

setBatteryState(level: number, isCharging: boolean): Promise<void>

getBatteryLevel(): Promise<number | null>

getIsCharging(): Promise<boolean>

setRelayPriority(priority: RelayPriority | "low" | "medium" | "high"): Promise<void>

getRelayPriority(): Promise<RelayPriority>

updateRelayConfig(config: RelayConfig): Promise<void>

getRelayConfig(): Promise<Required<RelayConfig>>

isRelay(): Promise<boolean>

getBLePeerCount(): Promise<number>

getBleDiagnostics(): Promise<BleDiagnostics>

getTransportMetrics(transportType: TransportType): Promise<TransportMetrics | null>

enableTelemetry(config: TelemetryConfig): Promise<void>

disableTelemetry(): Promise<void>

flushTelemetry(): Promise<void>

telemetryStats(): Promise<TelemetryStats | null>

endTelemetrySession(): Promise<void>

setTelemetryEnabled(enabled: boolean): Promise<void>

telemetryInstallId(): Promise<string | null>

forceTransport(transportType: TransportType): Promise<void>

releaseTransportLock(): Promise<void>

updateDorsConfig(config: { preferOnline?: boolean; switchHysteresis?: number; switchCooldownSecs?: number; bleToWifiRetryThreshold?: number; minSuccessRateBeforeEscalation?: number; minBleSamplesBeforeSuccessRateEscalation?: number; rssiSwitchThreshold?: number; congestionQueueThreshold?: number; stabilityWindowSecs?: number; poorSignalDurationSecs?: number; ttlEscalationThreshold?: number; congestionDurationSecs?: number; ttlEscalationHoldSecs?: number; historyWindowSize?: number; queueRecoveryRatio?: number; lowBatteryThreshold?: number; relayMinBatteryLevel?: number; relayOptimalConnectionCount?: number; }): Promise<void>

getDorsConfig(): Promise<{
    preferOnline: boolean;
    switchHysteresis: number;
    switchCooldownSecs: number;
    bleToWifiRetryThreshold: number;
    minSuccessRateBeforeEscalation: number;
    minBleSamplesBeforeSuccessRateEscalation: number;
    rssiSwitchThreshold: number;
    congestionQueueThreshold: number;
    stabilityWindowSecs: number;
    poorSignalDurationSecs: number;
    ttlEscalationThreshold: number;
    congestionDurationSecs: number;
    ttlEscalationHoldSecs: number;
    historyWindowSize: number;
    queueRecoveryRatio: number;
    lowBatteryThreshold: number;
    relayMinBatteryLevel: number;
    relayOptimalConnectionCount: number;
  }>

updateAckConfig(config: AckConfig): Promise<void>

updateRetryConfig(config: RetryConfig): Promise<void>

updateDedupConfig(config: DedupConfig): Promise<void>

getDedupStats(): Promise<DedupStats>

getMeshRelayStats(): Promise<MeshRelayStats>

getMeshRelayTunables(): Promise<MeshRelayTunables>

getCustodyStats(): Promise<CustodyStats>

eraseCustody(): Promise<void>

getPendingAckCount(): Promise<number>

getRetryQueueSize(): Promise<number>

shouldEscalateToWifi(): Promise<boolean>

processFileChunk(fileId: string, chunkIndex: number, totalChunks: number, fileSize: number, fileName: string, fileChecksum: string, data: number[]): Promise<void>

finalizeFile(fileId: string): Promise<void>

wifiDirectStatusChanged(isConnected: boolean): Promise<void>

wifiDirectMessageReceived(senderId: string, data: number[]): Promise<void>

wifiDirectGetNextMessage(): Promise<{
    recipientId: string;
    data: number[];
  } | null>

wifiDirectPeerConnected(peerId: string): Promise<void>

wifiDirectPeerDisconnected(peerId: string): Promise<void>

internetStatusChanged(isConnected: boolean): Promise<void>

internetMessageReceived(senderId: string, data: number[]): Promise<void>

internetGetNextMessage(): Promise<{
    messageId: string;
    recipientId: string;
    data: number[];
  } | null>

internetConfirmSent(messageId: string): Promise<void>

internetSendFailed(messageId: string): Promise<void>

initializeMlsWithSecureStorage(): Promise<void>

isMlsInitialized(): Promise<boolean>

getIdentityPublicKey(): Promise<number[]>

deriveAddress(publicKey: number[]): Promise<string>

parseInvite(blob: string): Promise<InviteInfo>

createInvite(petname?: string, signed = false): Promise<string>

resolveUsername(username: string): Promise<boolean>

localAddress(): Promise<string | null>

deriveUserIdFromPublicKey(publicKey: number[]): Promise<string>

signData(data: number[]): Promise<number[]>

verifySignature(publicKey: number[], data: number[], signature: number[]): Promise<boolean>

mlsGenerateKeyPackage(): Promise<MlsKeyPackage>

mlsGetOrCreateKeyPackage(): Promise<MlsKeyPackage>

mlsGetPendingKeyPackages(): Promise<MlsKeyPackage[]>

mlsMarkKeyPackageSynced(packageId: string): Promise<void>

mlsImportKeyPackage(userId: string, keyPackageData: number[]): Promise<void>

mlsHasSession(otherUserId: string): Promise<boolean>

hasPendingKeyPackage(peerId: string): Promise<boolean>

getEstablishmentState(peerId: string): Promise<EstablishmentState>

establishSecureSession(peerId: string): Promise<MlsWelcome | null>

rekeySession(peerId: string): Promise<boolean>

mlsCreateSession(otherUserId: string): Promise<MlsWelcome>

mlsJoinSession(welcome: MlsWelcome): Promise<MlsSessionInfo>

mlsEncryptForUser(otherUserId: string, plaintext: number[]): Promise<MlsEncryptedMessage>

mlsDecryptFromUser(encrypted: MlsEncryptedMessage): Promise<number[] | null>

mlsDecrypt(encrypted: MlsEncryptedMessage): Promise<number[] | null>

mlsListSessions(): Promise<string[]>

mlsDeleteSession(otherUserId: string): Promise<void>

mlsProcessWelcome(welcome: MlsWelcome): Promise<MlsSessionInfo | MlsGroupInfo>

meshCreateGroup(groupName: string): Promise<MlsGroupInfo>

meshInviteToGroup(groupId: string, inviteeUserId: string): Promise<void>

meshSendGroupMessage(groupId: string, content: string, priority?: string | null, replyToMsg?: string | null): Promise<string[]>

meshForwardMessageToGroup(params: ForwardMessageToGroupParams): Promise<string[]>

meshRemoveFromGroup(groupId: string, memberId: string): Promise<void>

meshLeaveGroup(groupId: string): Promise<void>

meshListGroups(): Promise<string[]>

meshGetGroupInfo(groupId: string): Promise<MlsGroupInfo | null>

meshGroupRichReadiness(groupId: string): Promise<GroupRichReadiness>

groupRelaySyncState(groupId: string): Promise<RelaySyncState>

requestGroupRelayRegistration(groupId: string): Promise<boolean>

ensureGroupRegistered(groupId: string, options?: { timeoutMs?: number }): Promise<void>

meshSetMemberRole(groupId: string, userId: string, role: string): Promise<void>

meshGetMemberRole(groupId: string, userId: string): Promise<string>

meshGetGroupRoles(groupId: string): Promise<Record<string, string>>

meshRenameGroup(groupId: string, newName: string): Promise<void>

destroy(): Promise<void>

wipePersistedState(appId: string, profile: string): Promise<void>

sendPresenceUpdate(recipient: string, status: 'online' | 'away' | 'offline'): Promise<string>

checkInternetPresence(userId: string, options?: { force?: boolean }): Promise<boolean>

sendRawServerCommand(json: string): Promise<boolean>

isInternetReady(): Promise<boolean>

if (await sdk.isInternetSuperseded()) {
  // Surface "connected elsewhere" and let the user decide.
  await sdk.enableTransport('internet', { serverAddress });  // clears the latch
}

isInternetSuperseded(): Promise<boolean>

forceInternetReconnect(): Promise<boolean>

sendTypingIndicator(recipient: string, conversationId: string, isTyping: boolean): Promise<string>

sendReadReceipt(recipient: string, messageIds: string[]): Promise<string>

blockUser(userId: string): Promise<void>

unblockUser(userId: string): Promise<void>

getBlockedUsers(): Promise<string[]>

isUserBlocked(userId: string): Promise<boolean>

createDoc(spaceId: string, docId: string): Promise<void>

deleteDoc(spaceId: string, docId: string): Promise<void>

removeDoc(spaceId: string, docId: string): Promise<void>

removeSpace(spaceId: string): Promise<void>

fetchAttachmentFrom(spaceId: string, peerId: string, hash: string): Promise<void>

setInterest(spaceId: string, patterns: string[]): Promise<void>

listDocs(spaceId: string): Promise<string[]>

listSpaces(): Promise<string[]>

mapSet(spaceId: string, docId: string, collection: string, key: string, value: DataValue): Promise<void>

mapDelete(spaceId: string, docId: string, collection: string, key: string): Promise<void>

mapGet(spaceId: string, docId: string, collection: string, key: string): Promise<DataValue | null>

listPush(spaceId: string, docId: string, collection: string, value: DataValue): Promise<void>

listDelete(spaceId: string, docId: string, collection: string, index: number, count: number): Promise<void>

listLength(spaceId: string, docId: string, collection: string): Promise<number>

textInsert(spaceId: string, docId: string, collection: string, position: number, text: string): Promise<void>

textDelete(spaceId: string, docId: string, collection: string, position: number, count: number): Promise<void>

textValue(spaceId: string, docId: string, collection: string): Promise<string>

counterIncrement(spaceId: string, docId: string, collection: string, amount: number): Promise<void>

counterValue(spaceId: string, docId: string, collection: string): Promise<number>

docJson(spaceId: string, docId: string): Promise<unknown>

exportRaw(spaceId: string, docId: string): Promise<string>

flush(spaceId: string, docId: string): Promise<void>

flushAll(): Promise<void>

docSize(spaceId: string, docId: string): Promise<number>

wipeAll(): Promise<void>

const hash = await store.attachmentHash(bytesBase64);
await store.mapSet(space, 'notes', 'files', 'plan', {
  kind: 'attachment', hash, size: byteLength, name: 'plan.pdf',
});

attachmentHash(bytesBase64: string): Promise<string>

fetchAttachment(spaceId: string, hash: string): Promise<void>

provideAttachment(spaceId: string, peerId: string, hash: string, bytesBase64: string): Promise<void>

declineAttachment(spaceId: string, peerId: string, hash: string): Promise<void>

registerService(serviceId: string, version: string, capabilities: Record<string, string> = {}): Promise<void>

unregisterService(serviceId: string): Promise<boolean>

discoverServices(serviceId?: string): Promise<string>

sendServiceRequest(provider: string, serviceId: string, method: string, body: string): Promise<string>

respondToServiceRequest(requestId: string, requester: string, serviceId: string, status: string, body: string): Promise<string>

registerMeshWakeTask(task: (data: MeshWakeTaskData) => Promise<void>): void