> ## Documentation Index
> Fetch the complete documentation index at: https://www.offlineprotocol.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> These docs target Mesh SDK v0.27.0. Match the installed package and binding before generating code. Start at /getting-started/agents for task-specific reading paths.
> Call the company and product Offline Protocol, never Offline alone. Current packages: @offline-protocol/mesh-sdk 0.27.0 (React Native), @offline-protocol/id-react 0.2.0, @offline-protocol/id-react-native 0.3.3, @offline-protocol/pol 0.1.2 and @offline-protocol/cli 0.2.6. Canonical docs URLs start with https://www.offlineprotocol.com/docs.
> The Mesh SDK runs in a native app or gateway. A browser OfflineID SDK integration does not provide browser mesh transport. Local mesh operation does not require a portal API key.
> Service RPC is signed plaintext in v0.27.0. Message delivery, durable local acceptance and backend commit are distinct outcomes. Use the workflow guide for the required application logic.
> Offline Protocol CLI 0.2.6 is on npm (@offline-protocol/cli, command offline). Its local MCP server runs with offline mcp serve and requires no login or key. Hosted MCP is at https://mcp.offlineprotocol.com/mcp with an application API key in Authorization: Bearer and a matching x-app-id; organization keys are rejected. Follow /tools/overview for setup and do not invent commands beyond it. MCP provides integration context and planning, not mesh execution; file-writing tools are local only.
> Phone Wi-Fi Direct and MultipeerConnectivity carry no data in v0.27.0. Use BLE or a provisioned relay. The receiver core ACKs before application persistence; use application acceptance for durable workflows.
> Proof of Location is Sepolia testnet witness evidence, not zero-knowledge proof or proof of presence. The geohash is public onchain. Read /proof-of-location/security before integration.

# Public types

> Complete exported parameter, result and event TypeScript types for the Offline Protocol Mesh SDK v0.27.0 React Native package.

These declarations match the published v0.27.0 package. See [methods](/docs/mesh-sdk/reference), [events](/docs/mesh-sdk/events) and [configuration defaults](/docs/mesh-sdk/configuration) for semantics. Standard TypeScript and React Native types retain their upstream definitions.

## MessagePriority

```typescript theme={null}
export enum MessagePriority {
  Low = 0,
  Medium = 1,
  High = 2,
  Critical = 3,
}
```

## ProtocolState

```typescript theme={null}
export enum ProtocolState {
  Stopped = "Stopped",
  Running = "Running",
  Paused = "Paused",
}
```

## AckConfig

```typescript theme={null}
export interface AckConfig {
  defaultTimeoutMs?: number;
  maxPendingAcks?: number;
}
```

## RetryConfig

```typescript theme={null}
export interface RetryConfig {
  maxRetries?: number;
  initialDelayMs?: number;
  maxDelayMs?: number;
  backoffMultiplier?: number;
  outboxMaxLifetimeMs?: number;
  pendingMessageMaxLifetimeMs?: number;
  edgeDrivenUnreachableDm?: boolean;
}
```

## DedupConfig

```typescript theme={null}
export interface DedupConfig {
  maxTrackedMessages?: number;
  retentionTimeSecs?: number;
}
```

## MeshRelayConfig

```typescript theme={null}
export interface MeshRelayConfig {
  maxTtl?: number;
  denseMaxTtl?: number;
  denseDegree?: number;
  fanout?: number;
  jitterMinMs?: number;
  jitterMaxMs?: number;
  ratePerSec?: number;
  burst?: number;
  peerRatePerSec?: number;
  peerBurst?: number;
  queueCapacity?: number;
  biasMinScale?: number;
  biasMaxHandicapMs?: number;
  activityWindowMs?: number;
  activityMinForwards?: number;
  activityIdleWindows?: number;
}
```

## MeshRelayTunables

```typescript theme={null}
export interface MeshRelayTunables {
  maxTtl: number;
  denseMaxTtl: number;
  denseDegree: number;
  fanout: number;
  jitterMinMs: number;
  jitterMaxMs: number;
  ratePerSec: number;
  burst: number;
  peerRatePerSec: number;
  peerBurst: number;
  queueCapacity: number;
  biasMinScale: number;
  biasMaxHandicapMs: number;
  activityWindowMs: number;
  activityMinForwards: number;
  activityIdleWindows: number;
}
```

## MeshRelayStats

```typescript theme={null}
export interface MeshRelayStats {
  forwarded: number;
  transmissions: number;
  queued: number;
  awaitingTransmission: number;
  duplicatesSuppressed: number;
  coveredByANeighbor: number;
  peerRateLimited: number;
  refusedQueueFull: number;
  rateDeferred: number;
  abandonedOverdue: number;
  hopLimitReached: number;
  reachClamped: number;
  droppedForCapacity: number;
}
```

## DedupStats

```typescript theme={null}
export interface DedupStats {
  totalTracked: number;
  recentTracked: number;
  capacityUsedPercent: number;
  mode: string;
}
```

## ReliabilityConfig

```typescript theme={null}
export interface ReliabilityConfig {
  ack?: AckConfig;
  retry?: RetryConfig;
  dedup?: DedupConfig;
}
```

## RelayPriority

```typescript theme={null}
export type RelayPriority = 'never' | 'auto' | 'always';
```

## RelayConfig

```typescript theme={null}
export interface RelayConfig {
  allowRelay?: boolean;
  minBatteryForRelay?: number;
  relayPriority?: RelayPriority;
}
```

## NetworkConfig

```typescript theme={null}
export interface NetworkConfig {
  initialTtl?: number;
}
```

## BleTransportConfig

```typescript theme={null}
export interface BleTransportConfig {
  enabled: boolean;
}
```

## InternetTransportConfig

```typescript theme={null}
export interface InternetTransportConfig {
  enabled: boolean;
  serverAddress?: string;
  autoReconnect?: boolean;
  reconnectDelay?: number;
  authToken?: string;
}
```

## WifiDirectTransportConfig

```typescript theme={null}
export interface WifiDirectTransportConfig {
  enabled: boolean;
  deviceName?: string;
  autoAccept?: boolean;
  groupOwnerIntent?: number;
}
```

## ReticulumTransportConfig

```typescript theme={null}
export interface ReticulumTransportConfig {
  enabled: boolean;
  daemonAddress?: string;
  autoReconnect?: boolean;
  maxReconnectAttempts?: number;
}
```

## NostrTransportConfig

```typescript theme={null}
export interface NostrTransportConfig {
  enabled: boolean;
  relayUrls?: string[];
  connectionTimeout?: number;
  autoReconnect?: boolean;
  reconnectDelay?: number;
  maxReconnectAttempts?: number;
  sealingEnabled?: boolean;
  coldContactEnabled?: boolean;
  usernameDiscoveryEnabled?: boolean;
}
```

## ContentType

```typescript theme={null}
export enum ContentType {
  Text = 'text',
  Image = 'image',
  Video = 'video',
  Audio = 'audio',
  VoiceNote = 'voice_note',
  VideoNote = 'video_note',
  File = 'file',
  FileChunk = 'file_chunk',
  Poll = 'poll',
}
```

## MediaMetadata

```typescript theme={null}
export interface MediaMetadata {
  mimeType: string;
  fileName: string;
  fileSize: number;
  durationMs?: number;
  width?: number;
  height?: number;
  thumbnailBase64?: string;
  mediaId?: string;
  downloadUrl?: string;
  thumbnailUrl?: string;
  encryptionKey?: string;
  iv?: string;
  ciphertextHash?: string;
  stickerProvider?: string;
  stickerRemoteId?: string;
  stickerKind?: string;
}
```

## FileTransferConfig

```typescript theme={null}
export interface FileTransferConfig {
  chunkSize?: number;
  maxFileSize?: number;
}
```

## FileProgress

```typescript theme={null}
export interface FileProgress {
  file_id: string;
  chunks_sent: number;
  total_chunks: number;
  percentage: number;
}
```

## TransportsConfig

```typescript theme={null}
export interface TransportsConfig {
  ble?: BleTransportConfig;
  internet?: InternetTransportConfig;
  wifiDirect?: WifiDirectTransportConfig;
  reticulum?: ReticulumTransportConfig;
  nostr?: NostrTransportConfig;
}
```

## EncryptionConfig

```typescript theme={null}
export interface EncryptionConfig {
  enabled?: boolean;
  autoKeyExchange?: boolean;
  storePending?: boolean;
  requireEncryption?: boolean;
  compactEnvelopeEnabled?: boolean;
  richPayloadEnabled?: boolean;
  cryptoRecoveryEnabled?: boolean;
  pendingQueue?: PendingQueueConfig;
}
```

## OverflowPolicy

```typescript theme={null}
export type OverflowPolicy = 'drop_oldest' | 'drop_newest';
```

## PendingQueueConfig

```typescript theme={null}
export interface PendingQueueConfig {
  maxPendingPerPeer?: number;
  maxPendingGlobal?: number;
  pendingTtlMs?: number;
  overflowPolicy?: OverflowPolicy;
}
```

## DataConfig

```typescript theme={null}
export interface DataConfig {
  enabled?: boolean;
}
```

## ProtocolConfig

```typescript theme={null}
export interface ProtocolConfig {
  appId: string;
  profile: string;
  transports?: TransportsConfig;
  binaryWireEnabled?: boolean;
  fileTransfer?: FileTransferConfig;
  encryption?: EncryptionConfig;
  group?: {
    maxGroupMembers?: number;
    relayEnabled?: boolean;
    relayBroadcastEnabled?: boolean;
    enforceAdminCommits?: boolean;
  };
  dors?: {
    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;
  };
  meshRelay?: MeshRelayConfig;
  relay?: RelayConfig;
  network?: NetworkConfig;
  reliability?: ReliabilityConfig;
  data?: DataConfig;
  security?: SecurityConfig;
  controlFreshnessEnforced?: boolean;
}
```

## SecurityConfig

```typescript theme={null}
export interface SecurityConfig {
  controlFreshnessEnforced?: boolean;
}
```

## TransportType

```typescript theme={null}
export type TransportType = 'ble' | 'internet' | 'wifiDirect' | 'reticulum' | 'nostr';
```

## ForwardInfo

```typescript theme={null}
export interface ForwardInfo {
  original_sender: string;
  original_message_id: string;
  original_timestamp: number;
  forward_count: number;
}
```

## ReplyContext

```typescript theme={null}
export interface ReplyContext {
  sender: string;
  text: string;
  timestamp?: number;
  reply_media_label?: string;
  reply_content_type?: string;
}
```

## MediaMetadataEvent

```typescript theme={null}
export interface MediaMetadataEvent {
  mime_type?: string;
  file_name?: string;
  file_size?: number;
  duration_ms?: number;
  width?: number;
  height?: number;
  thumbnail_base64?: string;
  media_id?: string;
  download_url?: string;
  thumbnail_url?: string;
  encryption_key?: string;
  iv?: string;
  ciphertext_hash?: string;
  sticker_provider?: string;
  sticker_remote_id?: string;
  sticker_kind?: string;
}
```

## ForwardMessageParams

```typescript theme={null}
export interface ForwardMessageParams {
  originalMessageJson: string;
  newRecipient: string;
  priority?: MessagePriority;
}
```

## ForwardMessageToGroupParams

```typescript theme={null}
export interface ForwardMessageToGroupParams {
  originalMessageJson: string;
  groupId: string;
  priority?: MessagePriority;
}
```

## SendMessageParams

```typescript theme={null}
export interface SendMessageParams {
  recipient: string;
  content: string;
  priority?: MessagePriority;
  replyToMsg?: string;
  contentType?: ContentType;
  replyContext?: ReplyContext;
  mediaMetadata?: MediaMetadata;
  forwardInfo?: ForwardInfo;
}
```

## SendConnectionRequestParams

```typescript theme={null}
export interface SendConnectionRequestParams {
  recipient: string;
  senderName: string;
  keyPackage?: number[];
  initialMessage?: string;
}
```

## AcceptConnectionRequestParams

```typescript theme={null}
export interface AcceptConnectionRequestParams {
  recipient: string;
  accepterName: string;
  keyPackage?: number[];
}
```

## RejectConnectionRequestParams

```typescript theme={null}
export interface RejectConnectionRequestParams {
  recipient: string;
}
```

## CancelConnectionRequestParams

```typescript theme={null}
export interface CancelConnectionRequestParams {
  recipient: string;
}
```

## SendMediaParams

```typescript theme={null}
export interface SendMediaParams {
  recipient: string;
  fileData: string;
  fileName: string;
  contentType: ContentType;
  mediaMetadata?: MediaMetadata;
  caption?: string;
  replyToMsg?: string;
  replyContext?: ReplyContext;
  forwardInfo?: ForwardInfo;
  fileId?: string;
}
```

## SendFileParams

```typescript theme={null}
export interface SendFileParams {
  recipient: string;
  fileData: string;
  fileName: string;
}
```

## MessageSentEvent

```typescript theme={null}
export interface MessageSentEvent extends BaseEvent {
  type: 'message_sent';
  message_id: string;
  sender: string;
  recipient: string;
  content: string;
  priority: 'low' | 'medium' | 'high' | 'critical';
  requires_ack: boolean;
  timestamp: number;
  lamport_clock: number;
  forward_info?: ForwardInfo;
}
```

## MessageReceivedEvent

```typescript theme={null}
export interface MessageReceivedEvent extends BaseEvent {
  type: 'message_received';
  message_id: string;
  sender: string;
  recipient: string;
  content: string;
  hop_count: number;
  transport: string;
  timestamp: number;
  lamport_clock: number;
  encrypted?: boolean;
  reply_to_msg?: string;
  reply_context?: ReplyContext;
  content_type?: string;
  media_metadata?: MediaMetadataEvent;
  forward_info?: ForwardInfo;
}
```

## MessageDeliveredEvent

```typescript theme={null}
export interface MessageDeliveredEvent extends BaseEvent {
  type: 'message_delivered';
  message_id: string;
  latency_ms: number;
  hop_count: number;
  transport: string;
}
```

## MessageFailedEvent

```typescript theme={null}
export interface MessageFailedEvent extends BaseEvent {
  type: 'message_failed';
  message_id: string;
  reason: string;
  retry_count: number;
}
```

## DecryptionFailureCode

```typescript theme={null}
export type DecryptionFailureCode =
  | 'INVALID_PAYLOAD'
  | 'NOT_INITIALIZED'
  | 'INVALID_CIPHERTEXT'
  | 'IDENTITY_MISMATCH'
  | 'CRYPTO_FAILURE'
  | 'PENDING_QUEUE_DROPPED'
  | 'UNKNOWN';
```

## MessageDecryptionFailedEvent

```typescript theme={null}
export interface MessageDecryptionFailedEvent extends BaseEvent {
  type: 'message_decryption_failed';
  message_id: string;
  sender: string;
  code: DecryptionFailureCode;
  reason: string;
}
```

## TransportSwitchedEvent

```typescript theme={null}
export interface TransportSwitchedEvent extends BaseEvent {
  type: 'transport_switched';
  from: string | null;
  to: string;
  reason: string;
}
```

## RelayPromotedEvent

```typescript theme={null}
export interface RelayPromotedEvent extends BaseEvent {
  type: 'relay_promoted';
  connection_count: number;
  battery_level: number | null;
}
```

## RelayDemotedEvent

```typescript theme={null}
export interface RelayDemotedEvent extends BaseEvent {
  type: 'relay_demoted';
  reason: string;
}
```

## RelayDemotedBatteryEvent

```typescript theme={null}
export interface RelayDemotedBatteryEvent extends BaseEvent {
  type: 'relay_demoted_battery';
  battery_level: number;
  min_required: number;
}
```

## NeighborDiscoveredEvent

```typescript theme={null}
export interface NeighborDiscoveredEvent extends BaseEvent {
  type: 'neighbor_discovered';
  peer_id: string;
  transport: string;
  rssi?: number;
}
```

## NeighborLostEvent

```typescript theme={null}
export interface NeighborLostEvent extends BaseEvent {
  type: 'neighbor_lost';
  peer_id: string;
}
```

## IdentityReadyEvent

```typescript theme={null}
export interface IdentityReadyEvent extends BaseEvent {
  type: 'identity_ready';
  address: string;
}
```

## NetworkMetricsEvent

```typescript theme={null}
export interface NetworkMetricsEvent extends BaseEvent {
  type: 'network_metrics';
  neighbor_count: number;
  relay_count: number;
  delivery_ratio: number;
  avg_latency_ms: number;
}
```

## FileProgressEvent

```typescript theme={null}
export interface FileProgressEvent extends BaseEvent {
  type: 'file_progress';
  file_id: string;
  chunks_sent: number;
  total_chunks: number;
  percentage: number;
}
```

## FileReceivedEvent

```typescript theme={null}
export interface FileReceivedEvent extends BaseEvent {
  type: 'file_received';
  file_id: string;
  file_name: string;
  file_size: number;
  sender: string;
  content_type: string;
  media_metadata?: MediaMetadataEvent;
  file_data: string;
  timestamp?: number;
  caption?: string;
  reply_to_msg?: string;
  reply_context?: ReplyContext;
  forward_info?: ForwardInfo;
}
```

## FileReceiveFailedEvent

```typescript theme={null}
export interface FileReceiveFailedEvent extends BaseEvent {
  type: 'file_receive_failed';
  file_id: string;
  file_name: string;
  sender: string;
  reason: string;
}
```

## MediaSentEvent

```typescript theme={null}
export interface MediaSentEvent extends BaseEvent {
  type: 'media_sent';
  file_id: string;
  content_type: string;
  recipient: string;
}
```

## MediaSendFailedEvent

```typescript theme={null}
export interface MediaSendFailedEvent extends BaseEvent {
  type: 'media_send_failed';
  file_id: string;
  recipient: string;
  reason: string;
}
```

## AckEvictedEvent

```typescript theme={null}
export interface AckEvictedEvent extends BaseEvent {
  type: 'ack_evicted';
  message_id: string;
  priority: string;
  reason: string;
}
```

## FragmentAssemblyEvictedEvent

```typescript theme={null}
export interface FragmentAssemblyEvictedEvent extends BaseEvent {
  type: 'fragment_assembly_evicted';
  message_id: string;
  completion_percent: number;
  reason: string;
}
```

## DiagnosticEvent

```typescript theme={null}
export interface DiagnosticEvent extends BaseEvent {
  type: 'diagnostic';
  level: 'info' | 'warning' | 'error';
  message: string;
  context?: Record<string, unknown>;
}
```

## SecureSessionEstablishedEvent

```typescript theme={null}
export interface SecureSessionEstablishedEvent extends BaseEvent {
  type: 'secure_session_established';
  peer_id: string;
  group_id: string;
  is_session: boolean;
  initiated_by_local: boolean;
}
```

## SecureSessionFailedEvent

```typescript theme={null}
export interface SecureSessionFailedEvent extends BaseEvent {
  type: 'secure_session_failed';
  peer_id: string;
  reason: string;
}
```

## ConvergenceDiagEvent

```typescript theme={null}
export interface ConvergenceDiagEvent extends BaseEvent {
  type: 'convergence_diag';
  stage: string;
  peer_id: string;
  detail: string;
}
```

## WelcomeReasonCode

```typescript theme={null}
export type WelcomeReasonCode =
  | 'TRANSPORT_UNAVAILABLE'
  | 'PEER_UNREACHABLE'
  | 'PEER_DISCONNECTED'
  | 'TIMEOUT'
  | 'INTERNAL_ERROR'
  | 'RETRY_EXHAUSTED';
```

## WelcomeSendAttemptedEvent

```typescript theme={null}
export interface WelcomeSendAttemptedEvent extends BaseEvent {
  type: 'welcome_send_attempted';
  peer_id: string;
  message_id: string;
  group_id: string;
  attempt: number;
}
```

## WelcomeSendSucceededEvent

```typescript theme={null}
export interface WelcomeSendSucceededEvent extends BaseEvent {
  type: 'welcome_send_succeeded';
  peer_id: string;
  message_id: string;
  group_id: string;
  attempt: number;
}
```

## WelcomeSendFailedEvent

```typescript theme={null}
export interface WelcomeSendFailedEvent extends BaseEvent {
  type: 'welcome_send_failed';
  peer_id: string;
  message_id: string;
  group_id: string;
  attempt: number;
  reason_code: WelcomeReasonCode;
  transport_error?: string;
  retryable: boolean;
  next_retry_at?: number;
}
```

## WelcomeSendExpiredEvent

```typescript theme={null}
export interface WelcomeSendExpiredEvent extends BaseEvent {
  type: 'welcome_send_expired';
  peer_id: string;
  message_id: string;
  attempt: number;
  reason_code: WelcomeReasonCode;
}
```

## ConnectionRequestReceivedEvent

```typescript theme={null}
export interface ConnectionRequestReceivedEvent extends BaseEvent {
  type: 'connection_request_received';
  sender: string;
  sender_name: string;
  timestamp: number;
  key_package?: number[];
  initial_message?: string;
}
```

## ConnectionRequestUndeliverableEvent

```typescript theme={null}
export interface ConnectionRequestUndeliverableEvent extends BaseEvent {
  type: 'connection_request_undeliverable';
  recipient: string;
  message_id: string;
  reason: string;
}
```

## ConnectionAcceptedEvent

```typescript theme={null}
export interface ConnectionAcceptedEvent extends BaseEvent {
  type: 'connection_accepted';
  accepted_by: string;
  accepted_by_name: string;
  timestamp: number;
  key_package?: number[];
}
```

## ConnectionRejectedEvent

```typescript theme={null}
export interface ConnectionRejectedEvent extends BaseEvent {
  type: 'connection_rejected';
  rejected_by: string;
}
```

## ConnectionRequestCancelledEvent

```typescript theme={null}
export interface ConnectionRequestCancelledEvent extends BaseEvent {
  type: 'connection_request_cancelled';
  cancelled_by: string;
}
```

## GroupCreatedEvent

```typescript theme={null}
export interface GroupCreatedEvent extends BaseEvent {
  type: 'group_created';
  group_id: string;
  name: string;
}
```

## GroupMessageReceivedEvent

```typescript theme={null}
export interface GroupMessageReceivedEvent extends BaseEvent {
  type: 'group_message_received';
  group_id: string;
  sender: string;
  content: string;
  timestamp: string;
  message_id: string;
  reply_to_msg?: string;
  forward_info?: ForwardInfo;
  media_metadata?: MediaMetadataEvent;
  content_type?: string;
}
```

## GroupMemberAddedEvent

```typescript theme={null}
export interface GroupMemberAddedEvent extends BaseEvent {
  type: 'group_member_added';
  group_id: string;
  user_id: string;
  added_by: string;
  group_name?: string;
  authorized?: boolean;
}
```

## GroupMemberRemovedEvent

```typescript theme={null}
export interface GroupMemberRemovedEvent extends BaseEvent {
  type: 'group_member_removed';
  group_id: string;
  user_id: string;
  removed_by: string;
  authorized?: boolean;
}
```

## GroupInfoMemberEvent

```typescript theme={null}
export interface GroupInfoMemberEvent {
  user_id: string;
  role: string;
  joined_at: string;
}
```

## GroupInfoEvent

```typescript theme={null}
export interface GroupInfoEvent extends BaseEvent {
  type: 'group_info';
  group_id: string;
  name: string;
  created_by: string;
  created_at: string;
  members: GroupInfoMemberEvent[];
}
```

## UserGroupSummaryEvent

```typescript theme={null}
export interface UserGroupSummaryEvent {
  group_id: string;
  name: string;
  created_at: string;
}
```

## UserGroupsEvent

```typescript theme={null}
export interface UserGroupsEvent extends BaseEvent {
  type: 'user_groups';
  groups: UserGroupSummaryEvent[];
}
```

## GroupErrorEvent

```typescript theme={null}
export interface GroupErrorEvent extends BaseEvent {
  type: 'group_error';
  reason: 'not_found' | 'sync_denied' | 'error';
  group_id?: string;
}
```

## GroupRelaySyncChangedEvent

```typescript theme={null}
export interface GroupRelaySyncChangedEvent extends BaseEvent {
  type: 'group_relay_sync_changed';
  group_id: string;
  synced: boolean;
  reason: string;
}
```

## InviteInfo

```typescript theme={null}
export interface InviteInfo {
  address: string;
  public_key: number[];
  petname: string | null;
  signed: boolean;
}
```

## UsernameClaim

```typescript theme={null}
export interface UsernameClaim {
  address: string;
  public_key: string;
  issued_at_ms: number;
}
```

## UsernameResolvedEvent

```typescript theme={null}
export interface UsernameResolvedEvent extends BaseEvent {
  type: 'username_resolved';
  username: string;
  claims: UsernameClaim[];
  rejected: number;
  truncated: number;
}
```

## GroupMessageSentEvent

```typescript theme={null}
export interface GroupMessageSentEvent extends BaseEvent {
  type: 'group_message_sent';
  group_id: string;
  message_ids: string[];
  member_count: number;
}
```

## GroupMessagePartialFailureEvent

```typescript theme={null}
export interface GroupMessagePartialFailureEvent extends BaseEvent {
  type: 'group_message_partial_failure';
  group_id: string;
  failed_members: string[];
  succeeded_members: string[];
}
```

## GroupMessageDeliveryReportEvent

```typescript theme={null}
export interface GroupMessageDeliveryReportEvent extends BaseEvent {
  type: 'group_message_delivery_report';
  group_id: string;
  message_id: string;
  delivered: string[];
  pushed: string[];
  missed_reissued: string[];
}
```

## GroupRichExtrasDroppedEvent

```typescript theme={null}
export interface GroupRichExtrasDroppedEvent extends BaseEvent {
  type: 'group_rich_extras_dropped';
  group_id: string;
  unknown_members: string[];
}
```

## GroupUnauthorizedMembershipChangeEvent

```typescript theme={null}
export interface GroupUnauthorizedMembershipChangeEvent extends BaseEvent {
  type: 'group_unauthorized_membership_change';
  group_id: string;
  committer: string;
  added: string[];
  removed: string[];
  reason: string;
  enforced: boolean;
}
```

## GroupEpochForkDetectedEvent

```typescript theme={null}
export interface GroupEpochForkDetectedEvent extends BaseEvent {
  type: 'group_epoch_fork_detected';
  group_id: string;
  local_epoch?: number;
}
```

## GroupEpochForkResolvedEvent

```typescript theme={null}
export interface GroupEpochForkResolvedEvent extends BaseEvent {
  type: 'group_epoch_fork_resolved';
  group_id: string;
  resolved_epoch: number;
  failed_members: string[];
}
```

## GroupRoleChangedEvent

```typescript theme={null}
export interface GroupRoleChangedEvent extends BaseEvent {
  type: 'group_role_changed';
  group_id: string;
  user_id: string;
  new_role: string;
  changed_by: string;
}
```

## GroupRenamedEvent

```typescript theme={null}
export interface GroupRenamedEvent extends BaseEvent {
  type: 'group_renamed';
  group_id: string;
  new_name: string;
  old_name: string | null;
  renamed_by: string;
}
```

## ServiceDiscoveredEvent

```typescript theme={null}
export interface ServiceDiscoveredEvent extends BaseEvent {
  type: 'service_discovered';
  query_id: string;
  service_id: string;
  version: string;
  provider_peer_id: string;
  capabilities: Record<string, string>;
  hop_count: number;
}
```

## ServiceRequestReceivedEvent

```typescript theme={null}
export interface ServiceRequestReceivedEvent extends BaseEvent {
  type: 'service_request_received';
  request_id: string;
  service_id: string;
  method: string;
  body: string;
  sender: string;
}
```

## ServiceResponseReceivedEvent

```typescript theme={null}
export interface ServiceResponseReceivedEvent extends BaseEvent {
  type: 'service_response_received';
  request_id: string;
  service_id: string;
  status: string;
  body: string;
  provider_peer_id: string;
}
```

## PresenceStatus

```typescript theme={null}
export type PresenceStatus = 'online' | 'away' | 'offline';
```

## PresenceSource

```typescript theme={null}
export type PresenceSource = 'internet' | 'reticulum' | 'peer';
```

## PresenceUpdatedEvent

```typescript theme={null}
export interface PresenceUpdatedEvent extends BaseEvent {
  type: 'presence_updated';
  peer_id: string;
  status: PresenceStatus;
  timestamp: number;
  last_seen_ms?: number;
  source: PresenceSource;
}
```

## TypingIndicatorReceivedEvent

```typescript theme={null}
export interface TypingIndicatorReceivedEvent extends BaseEvent {
  type: 'typing_indicator_received';
  sender: string;
  conversation_id: string;
  is_typing: boolean;
  timestamp: number;
}
```

## ReadReceiptReceivedEvent

```typescript theme={null}
export interface ReadReceiptReceivedEvent extends BaseEvent {
  type: 'read_receipt_received';
  sender: string;
  message_ids: string[];
  timestamp: number;
}
```

## MessageRelayedEvent

```typescript theme={null}
export interface MessageRelayedEvent extends BaseEvent {
  type: 'message_relayed';
  message_id: string;
  sender: string;
  recipient: string;
  hop_count: number;
  remaining_ttl: number;
}
```

## MessageDeferredEvent

```typescript theme={null}
export interface MessageDeferredEvent extends BaseEvent {
  type: 'message_deferred';
  message_id: string;
  recipient: string;
  reason: string;
  retry_count: number;
  next_retry_at?: number;
}
```

## MessageRetryingEvent

```typescript theme={null}
export interface MessageRetryingEvent extends BaseEvent {
  type: 'message_retrying';
  message_id: string;
  recipient: string;
  retry_count: number;
  next_retry_at: number;
}
```

## MessageUndeliverableEvent

```typescript theme={null}
export interface MessageUndeliverableEvent extends BaseEvent {
  type: 'message_undeliverable';
  message_id: string;
  recipient: string;
  reason: string;
  file_id?: string;
}
```

## MediaResendRequiredEvent

```typescript theme={null}
export interface MediaResendRequiredEvent extends BaseEvent {
  type: 'media_resend_required';
  file_id: string;
  recipient: string;
  file_name: string;
  file_size: number;
}
```

## DorsReasonCode

```typescript theme={null}
export type DorsReasonCode =
  | 'INITIAL_SELECTION'
  | 'PRIMARY_SELECTED'
  | 'PRIMARY_SUCCESS'
  | 'FALLBACK_SUCCESS'
  | 'ESCALATION_APPLIED'
  | 'CURRENT_UNAVAILABLE';
```

## DorsEscalationPhase

```typescript theme={null}
export type DorsEscalationPhase = 'TRIGGERED' | 'APPLIED';
```

## DorsEscalationReasonCode

```typescript theme={null}
export type DorsEscalationReasonCode =
  | 'FALLBACK_SUCCESS'
  | 'RETRY_THRESHOLD'
  | 'POOR_SIGNAL'
  | 'CONGESTION'
  | 'LOW_TTL'
  | 'LOW_SUCCESS_RATE';
```

## DorsScoreUpdatedEvent

```typescript theme={null}
export interface DorsScoreUpdatedEvent extends BaseEvent {
  type: 'dors_score_updated';
  scores: Array<[string, number]>;
}
```

## DorsTransportSelectedEvent

```typescript theme={null}
export interface DorsTransportSelectedEvent extends BaseEvent {
  type: 'dors_transport_selected';
  from: string | null;
  transport: string;
  reason_code: DorsReasonCode;
  score?: number;
}
```

## DorsTransportSwitchedEvent

```typescript theme={null}
export interface DorsTransportSwitchedEvent extends BaseEvent {
  type: 'dors_transport_switched';
  from: string | null;
  to: string;
  reason_code: DorsReasonCode;
  reason_detail?: string;
}
```

## DorsEscalationTriggeredEvent

```typescript theme={null}
export interface DorsEscalationTriggeredEvent extends BaseEvent {
  type: 'dors_escalation_triggered';
  phase: DorsEscalationPhase;
  from: string;
  to: string;
  reason_code: DorsEscalationReasonCode;
  reason_detail?: string;
}
```

## SecurityWarningCode

```typescript theme={null}
export type SecurityWarningCode =
  | 'SENDER_ADDRESS_MISMATCH'
  | 'TRANSPORT_IDENTITY_MISMATCH'
  | 'CONTROL_SIGNATURE_INVALID'
  | 'UNSIGNED_CONTROL_REJECTED'
  | 'MEDIA_SENDER_GROUP_MISMATCH'
  | 'PLAINTEXT_SEND'
  | 'PLAINTEXT_RECEIVE_REJECTED'
  | 'SESSION_SENDER_GROUP_MISMATCH'
  | 'SESSION_REKEY_TRIGGERED'
  | 'NOSTR_KEY_PACKAGE_SLOT_EXHAUSTED'
  | 'PUSH_KEY_PACKAGE_POOL_EXHAUSTED'
  | 'RELAY_ADDRESS_BINDING_MISMATCH'
  | 'RELAY_ADDRESS_DECLARATION_REFUSED'
  | 'GROUP_LEAF_IDENTITY_UNPROVEN'
  | 'STALE_CONTROL_FRAME'
  | 'GATEWAY_ADDRESS_BINDING_MISMATCH'
  | 'GATEWAY_ADDRESS_DECLARATION_REFUSED';
```

## SecurityWarningEvent

```typescript theme={null}
export interface SecurityWarningEvent extends BaseEvent {
  type: 'security_warning';
  peer_id: string;
  reason_code: SecurityWarningCode;
  reason: string;
}
```

## UserBlockedEvent

```typescript theme={null}
export interface UserBlockedEvent extends BaseEvent {
  type: 'user_blocked';
  user_id: string;
}
```

## UserUnblockedEvent

```typescript theme={null}
export interface UserUnblockedEvent extends BaseEvent {
  type: 'user_unblocked';
  user_id: string;
}
```

## DataChangedEvent

```typescript theme={null}
export interface DataChangedEvent extends BaseEvent {
  type: 'data_changed';
  space_id: string;
  doc_id: string;
  delta_bytes: number;
}
```

## DataDocRemovedEvent

```typescript theme={null}
export interface DataDocRemovedEvent extends BaseEvent {
  type: 'data_doc_removed';
  space_id: string;
  doc_id: string;
  by: 'local' | 'peer';
}
```

## DataDocSizeWarningEvent

```typescript theme={null}
export interface DataDocSizeWarningEvent extends BaseEvent {
  type: 'data_doc_size_warning';
  space_id: string;
  doc_id: string;
  compacted_bytes: number;
  cap_bytes: number;
}
```

## DataAttachmentRequestedEvent

```typescript theme={null}
export interface DataAttachmentRequestedEvent extends BaseEvent {
  type: 'data_attachment_requested';
  space_id: string;
  peer_id: string;
  hash: string;
}
```

## DataAttachmentReceivedEvent

```typescript theme={null}
export interface DataAttachmentReceivedEvent extends BaseEvent {
  type: 'data_attachment_received';
  space_id: string;
  peer_id: string;
  hash: string;
  data: string;
}
```

## DataAttachmentUnavailableEvent

```typescript theme={null}
export interface DataAttachmentUnavailableEvent extends BaseEvent {
  type: 'data_attachment_unavailable';
  space_id: string;
  peer_id: string;
  hash: string;
  reason: string;
}
```

## DataDocUnsyncableEvent

```typescript theme={null}
export interface DataDocUnsyncableEvent extends BaseEvent {
  type: 'data_doc_unsyncable';
  space_id: string;
  doc_id: string;
  bytes: number;
  reason: string;
}
```

## InternetServerMessageEvent

```typescript theme={null}
export interface InternetServerMessageEvent extends BaseEvent {
  type: 'internet_server_message';
  json: string;
}
```

## InternetStatusChangedEvent

```typescript theme={null}
export interface InternetStatusChangedEvent extends BaseEvent {
  type: 'internet_status_changed';
  connected: boolean;
  authenticated: boolean;
}
```

## InternetSessionSupersededEvent

```typescript theme={null}
export interface InternetSessionSupersededEvent extends BaseEvent {
  type: 'internet_session_superseded';
  reason?: string;
}
```

## MeshStoppedByUserEvent

```typescript theme={null}
export interface MeshStoppedByUserEvent extends BaseEvent {
  type: 'mesh_stopped_by_user';
}
```

## RelaySyncState

```typescript theme={null}
export type RelaySyncState = 'synced' | 'pending' | 'unsynced';
```

## ProtocolEvent

```typescript theme={null}
export type ProtocolEvent =
  | MessageSentEvent
  | MessageReceivedEvent
  | MessageDeliveredEvent
  | MessageFailedEvent
  | MessageDecryptionFailedEvent
  | TransportSwitchedEvent
  | RelayPromotedEvent
  | RelayDemotedEvent
  | RelayDemotedBatteryEvent
  | NeighborDiscoveredEvent
  | NeighborLostEvent
  | IdentityReadyEvent
  | NetworkMetricsEvent
  | FileProgressEvent
  | FileReceivedEvent
  | FileReceiveFailedEvent
  | MediaSentEvent
  | MediaSendFailedEvent
  | AckEvictedEvent
  | FragmentAssemblyEvictedEvent
  | DiagnosticEvent
  | SecureSessionEstablishedEvent
  | SecureSessionFailedEvent
  | ConvergenceDiagEvent
  | WelcomeSendAttemptedEvent
  | WelcomeSendSucceededEvent
  | WelcomeSendFailedEvent
  | WelcomeSendExpiredEvent
  | ConnectionRequestReceivedEvent
  | ConnectionRequestUndeliverableEvent
  | ConnectionAcceptedEvent
  | ConnectionRejectedEvent
  | ConnectionRequestCancelledEvent
  | GroupCreatedEvent
  | GroupMessageReceivedEvent
  | GroupMemberAddedEvent
  | GroupMemberRemovedEvent
  | GroupInfoEvent
  | UserGroupsEvent
  | GroupErrorEvent
  | GroupRelaySyncChangedEvent
  | UsernameResolvedEvent
  | GroupMessageSentEvent
  | GroupMessagePartialFailureEvent
  | GroupMessageDeliveryReportEvent
  | GroupRichExtrasDroppedEvent
  | GroupUnauthorizedMembershipChangeEvent
  | GroupEpochForkDetectedEvent
  | GroupEpochForkResolvedEvent
  | GroupRoleChangedEvent
  | GroupRenamedEvent
  | DorsScoreUpdatedEvent
  | DorsTransportSelectedEvent
  | DorsTransportSwitchedEvent
  | DorsEscalationTriggeredEvent
  | ServiceDiscoveredEvent
  | ServiceRequestReceivedEvent
  | ServiceResponseReceivedEvent
  | PresenceUpdatedEvent
  | InternetServerMessageEvent
  | InternetStatusChangedEvent
  | InternetSessionSupersededEvent
  | MeshStoppedByUserEvent
  | TypingIndicatorReceivedEvent
  | ReadReceiptReceivedEvent
  | MessageRelayedEvent
  | MessageDeferredEvent
  | MessageRetryingEvent
  | MessageUndeliverableEvent
  | MediaResendRequiredEvent
  | SecurityWarningEvent
  | UserBlockedEvent
  | UserUnblockedEvent
  | DataChangedEvent
  | DataDocRemovedEvent
  | DataDocSizeWarningEvent
  | DataAttachmentRequestedEvent
  | DataAttachmentReceivedEvent
  | DataAttachmentUnavailableEvent
  | DataDocUnsyncableEvent;
```

## EventListener

```typescript theme={null}
export type EventListener<T extends ProtocolEvent = ProtocolEvent> = (event: T) => void;
```

## EventType

```typescript theme={null}
export type EventType = ProtocolEvent['type'];
```

## NodeRole

```typescript theme={null}
export enum NodeRole {
  Normal = 'normal',
  Relay = 'relay',
}
```

## NetworkNode

```typescript theme={null}
export interface NetworkNode {
  user_id: string;
  role: NodeRole;
  connection_count: number;
  battery_level?: number;
  last_seen: number;
  transports: TransportType[];
}
```

## NetworkLink

```typescript theme={null}
export interface NetworkLink {
  from: string;
  to: string;
  quality: number;
  transport: TransportType;
  rssi?: number;
}
```

## NetworkStats

```typescript theme={null}
export interface NetworkStats {
  total_nodes: number;
  relay_nodes: number;
  total_connections: number;
  avg_link_quality: number;
  network_diameter?: number;
}
```

## NetworkTopology

```typescript theme={null}
export interface NetworkTopology {
  timestamp: number;
  local_user_id: string;
  nodes: NetworkNode[];
  links: NetworkLink[];
  stats: NetworkStats;
}
```

## MessageDeliveryStats

```typescript theme={null}
export interface MessageDeliveryStats {
  message_id: string;
  sender: string;
  recipient: string;
  sent_at: number;
  delivered_at?: number;
  hop_count: number;
  transport?: TransportType;
  retry_count: number;
  latency_ms?: number;
}
```

## ProcessFileChunkParams

```typescript theme={null}
export interface ProcessFileChunkParams {
  fileId: string;
  chunkIndex: number;
  data: number[];
}
```

## WifiDirectMessage

```typescript theme={null}
export interface WifiDirectMessage {
  recipientId: string;
  data: number[];
}
```

## InternetMessage

```typescript theme={null}
export interface InternetMessage {
  messageId: string;
  recipientId: string;
  data: number[];
}
```

## EstablishmentState

```typescript theme={null}
export type EstablishmentState =
  | 'NoKeyPackage'
  | 'HaveKeyPackage'
  | 'SessionPending'
  | 'SessionConfirmed';
```

## MlsKeyPackage

```typescript theme={null}
export interface MlsKeyPackage {
  packageId: string;
  userId: string;
  keyPackageData: number[];
  createdAt: number;
  isSynced: boolean;
}
```

## MlsEncryptedMessage

```typescript theme={null}
export interface MlsEncryptedMessage {
  groupId: string;
  messageType: string;
  epoch: number;
  ciphertext: number[];
  senderId: string;
  timestampMs: number;
}
```

## MlsWelcome

```typescript theme={null}
export interface MlsWelcome {
  groupId: string;
  welcomeData: number[];
  inviterId: string;
  timestampMs: number;
}
```

## MlsSessionInfo

```typescript theme={null}
export interface MlsSessionInfo {
  otherUserId: string;
  groupId: string;
  epoch: number;
  createdAt: number;
}
```

## MlsGroupInfo

```typescript theme={null}
export interface MlsGroupInfo {
  groupId: string;
  groupName: string;
  memberIds: string[];
  epoch: number;
  createdAt: number;
}
```

## GroupRichReadiness

```typescript theme={null}
export interface GroupRichReadiness {
  ready: boolean;
  unknownMembers: string[];
}
```

## MlsCommit

```typescript theme={null}
export interface MlsCommit {
  groupId: string;
  commitData: number[];
  newEpoch: number;
}
```

## MlsVerbosity

```typescript theme={null}
export type MlsVerbosity = 'off' | 'lifecycle' | 'diagnostic';
```

## TelemetryConfig

```typescript theme={null}
export interface TelemetryConfig {
  apiKey: string;
  appId: string;
  appVersion?: string;
  debug?: boolean;
  flushIntervalMs?: number;
  maxBatchBytes?: number;
  maxBufferedRecords?: number;
  includeDeviceId?: boolean;
  scrubIds?: boolean;
  mlsVerbosity?: MlsVerbosity;
  metricsCadenceMs?: number;
  routingDiagnostic?: boolean;
  mlsSamplingBypass?: boolean;
}
```

## TelemetryStats

```typescript theme={null}
export interface TelemetryStats {
  buffered: number;
  sentEvents: number;
  acceptedEvents: number;
  dropped: number;
  sessionId: string;
  lastError?: string;
  lastFlushAtMs?: number;
}
```

## BleDiagnostics

```typescript theme={null}
export interface BleDiagnostics {
  fragmentFallbacks: number;
  recipientNotAmongPeers: number;
  undersizedMtuReports: number;
}
```

## TransportMetrics

```typescript theme={null}
export interface TransportMetrics {
  packetsSent: number;
  packetsReceived: number;
  bytesSent: number;
  bytesReceived: number;
  errorRate: number;
  avgLatencyMs: number;
  rssi?: number;
  bandwidthBps?: number;
  congestion?: number;
  queueDepth?: number;
  batteryLevel?: number;
  isCharging?: boolean;
  relayConnectionCount?: number;
  isActiveRelay?: boolean;
  deliveryRatio?: number;
  dropRate?: number;
  averageHopCount?: number;
  energyCost?: number;
}
```

## MeshWakeTaskData

```typescript theme={null}
export interface MeshWakeTaskData {
  reason: 'sticky_restart' | (string & {});
}
```

## DataValue

```typescript theme={null}
export type DataValue =
  | { kind: 'null' }
  | { kind: 'bool'; value: boolean }
  | { kind: 'int'; value: number }
  | { kind: 'float'; value: number }
  | { kind: 'text'; value: string }
  | { kind: 'bytes'; value: number[] }
  | {
      kind: 'attachment';
      hash: string;
      size: number;
      name?: string;
      mime?: string;
    };
```

## Diagnostic level compatibility

The v0.27.0 `DiagnosticEvent.level` declaration omits `debug`, which native bridges can emit. Diagnostic consumers must tolerate that runtime value.