@xmtp/browser-sdk 5.3.0 → 6.0.1

package/dist/index.d.ts

@@ -1,9 +1,7 @@
-import { ContentCodec, ContentTypeId as ContentTypeId$1, EncodedContent as EncodedContent$1 } from '@xmtp/content-type-primitives';
 import * as _xmtp_wasm_bindings from '@xmtp/wasm-bindings';
-import { Identifier, Conversations as Conversations$1, ConsentState, Message, Conversation as Conversation$1, ConversationType, Client as Client$1, ConsentEntityType, Consent, UserPreference, SignatureRequestHandle, KeyPackageStatus, PermissionUpdateType, PermissionPolicy, MetadataField, EncodedContent, SendMessageOpts, MessageDisappearingSettings, HmacKey, ConversationDebugInfo, GroupPermissionsOptions, DeliveryStatus, GroupMessageKind, ContentType, SortDirection, MessageSortBy, PermissionLevel, ListConversationsOrderBy, ContentTypeId, ListMessagesOptions, ListConversationsOptions, PermissionPolicySet, CreateGroupOptions, CreateDMOptions, Installation, InboxState, GroupMember, ApiStats, IdentityStats, GroupSyncSummary } from '@xmtp/wasm-bindings';
-export { Consent, ConsentEntityType, ConsentState, ContentType, ContentTypeId, ConversationListItem, ConversationType, CreateDMOptions, CreateGroupOptions, DeliveryStatus, EncodedContent, GroupMember, GroupMembershipState, GroupMessageKind, GroupMetadata, GroupPermissions, GroupPermissionsOptions, GroupSyncSummary, HmacKey, Identifier, IdentifierKind, InboxState, Installation, ListConversationsOptions, ListMessagesOptions, LogOptions, Message, MessageDisappearingSettings, MetadataField, PermissionLevel, PermissionPolicy, PermissionPolicySet, PermissionUpdateType, SignatureRequestHandle, SortDirection, UserPreference } from '@xmtp/wasm-bindings';
-import { GroupUpdatedCodec } from '@xmtp/content-type-group-updated';
-import { TextCodec } from '@xmtp/content-type-text';
+import { ContentTypeId as ContentTypeId$1, DeliveryStatus, GroupMessageKind, Reaction, DecodedMessage as DecodedMessage$1, LeaveRequest, ReadReceipt, Attachment, RemoteAttachment, TransactionReference, WalletSendCalls, Actions, Intent, MultiRemoteAttachment, GroupUpdated, LogLevel, Identifier, Conversations as Conversations$1, ConsentState, ListConversationsOptions, CreateGroupOptions, CreateDmOptions, Conversation as Conversation$1, ConversationType, Message, Client as Client$1, Consent, ConsentEntityType, UserPreferenceUpdate, SignatureRequestHandle, KeyPackageStatus, GroupMember, PermissionUpdateType, PermissionPolicy, MetadataField, EncodedContent, SendMessageOpts, Reply, ListMessagesOptions, MessageDisappearingSettings, HmacKey, ConversationDebugInfo, GroupPermissionsOptions, PermissionPolicySet, GroupMetadata, ApiStats, IdentityStats, InboxState, GroupSyncSummary } from '@xmtp/wasm-bindings';
+export { Action, ActionStyle, Actions, ApiStats, Attachment, Consent, ConsentEntityType, ConsentState, ContentType, ConversationDebugInfo, ConversationListItem, ConversationType, CreateDmOptions, CreateGroupOptions, Cursor, DeliveryStatus, EncryptedAttachment, GroupMember, GroupMembershipState, GroupMessageKind, GroupMetadata, GroupPermissions, GroupPermissionsOptions, GroupSyncSummary, GroupUpdated, HmacKey, Identifier, IdentifierKind, IdentityStats, Inbox, InboxState, Installation, Intent, KeyPackageStatus, LeaveRequest, Lifetime, ListConversationsOptions, ListConversationsOrderBy, ListMessagesOptions, LogLevel, LogOptions, Message, MessageDisappearingSettings, MessageSortBy, MetadataField, MetadataFieldChange, MultiRemoteAttachment, PermissionLevel, PermissionPolicy, PermissionPolicySet, PermissionUpdateType, Reaction, ReactionAction, ReactionSchema, ReadReceipt, RemoteAttachment, RemoteAttachmentInfo, Reply, SendMessageOpts, SignatureRequestHandle, SortDirection, TransactionMetadata, TransactionReference, UserPreferenceUpdate, WalletCall, WalletSendCalls } from '@xmtp/wasm-bindings';
+import { ContentCodec, ContentTypeId } from '@xmtp/content-type-primitives';
 
 type ResolveValue<T> = {
     value: T;
@@ -111,6 +109,55 @@ declare const HistorySyncUrls: {
     readonly production: "https://message-history.production.ephemera.network";
 };
 
+declare class CodecRegistry {
+    #private;
+    constructor(codecs: ContentCodec[]);
+    /**
+     * Gets the codec for a given content type
+     *
+     * @param contentType - The content type to get the codec for
+     * @returns The codec, if found
+     */
+    getCodec<ContentType = unknown>(contentType: ContentTypeId): ContentCodec<ContentType> | undefined;
+}
+
+/**
+ * Represents a decoded XMTP message
+ *
+ * @class
+ * @property {unknown} 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 {DeliveryStatus} deliveryStatus - Current delivery status of the message ("unpublished" | "published" | "failed")
+ * @property {bigint} expiresAtNs - Timestamp when the message will expire (in nanoseconds)
+ * @property {Date} expiresAt - Timestamp when the message will expire
+ * @property {string} fallback - Optional fallback text for the message
+ * @property {string} id - Unique identifier for the message
+ * @property {GroupMessageKind} kind - Type of message ("application" | "membership_change")
+ * @property {bigint} numReplies - Number of replies to the message
+ * @property {DecodedMessage<Reaction>[]} reactions - Reactions to the message
+ * @property {string} senderInboxId - Identifier for the sender's inbox
+ * @property {Date} sentAt - Timestamp when the message was sent
+ * @property {bigint} sentAtNs - Timestamp when the message was sent (in nanoseconds)
+ */
+declare class DecodedMessage<ContentTypes = unknown> {
+    content: ContentTypes | undefined;
+    contentType: ContentTypeId$1;
+    conversationId: string;
+    deliveryStatus: DeliveryStatus;
+    expiresAtNs?: bigint;
+    expiresAt?: Date;
+    fallback?: string;
+    id: string;
+    kind: GroupMessageKind;
+    numReplies: bigint;
+    reactions: DecodedMessage<Reaction>[];
+    senderInboxId: string;
+    sentAt: Date;
+    sentAtNs: bigint;
+    constructor(codecRegistry: CodecRegistry, message: DecodedMessage$1);
+}
+
 type XmtpEnv = keyof typeof ApiUrls;
 /**
  * Network options
@@ -180,7 +227,7 @@ type OtherOptions = {
     /**
      * Logging level
      */
-    loggingLevel?: "off" | "error" | "warn" | "info" | "debug" | "trace";
+    loggingLevel?: LogLevel;
     /**
      * Disable automatic registration when creating a client
      */
@@ -193,13 +240,15 @@ type OtherOptions = {
      * Custom app version
      */
     appVersion?: string;
-    /**
-     * Should debug events be tracked
-     * (default: false)
-     */
-    debugEventsEnabled?: boolean;
 };
 type ClientOptions = NetworkOptions & ContentOptions & StorageOptions & OtherOptions;
+type EnrichedReply<T = unknown, U = unknown> = {
+    referenceId: string;
+    content: T;
+    inReplyTo: DecodedMessage<U> | null;
+};
+type BuiltInContentTypes = string | LeaveRequest | Reaction | ReadReceipt | Attachment | RemoteAttachment | TransactionReference | WalletSendCalls | Actions | Intent | MultiRemoteAttachment | GroupUpdated;
+type ExtractCodecContentTypes<C extends ContentCodec[] = []> = C extends readonly [] ? BuiltInContentTypes : [...C][number] extends ContentCodec<infer T> ? T | BuiltInContentTypes | EnrichedReply<T | BuiltInContentTypes, T | BuiltInContentTypes> : BuiltInContentTypes;
 
 type SignMessage = (message: string) => Promise<Uint8Array> | Uint8Array;
 type GetIdentifier = () => Promise<Identifier> | Identifier;
@@ -241,17 +290,17 @@ declare class WorkerConversations {
     sync(): Promise<void>;
     syncAll(consentStates?: ConsentState[]): Promise<_xmtp_wasm_bindings.GroupSyncSummary>;
     getConversationById(id: string): WorkerConversation | undefined;
-    getMessageById(id: string): Message | undefined;
+    getMessageById(id: string): Promise<DecodedMessage$1 | undefined>;
     getDmByInboxId(inboxId: string): WorkerConversation | undefined;
-    list(options?: SafeListConversationsOptions): WorkerConversation[];
-    listGroups(options?: Omit<SafeListConversationsOptions, "conversation_type">): WorkerConversation[];
-    listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">): WorkerConversation[];
-    newGroupOptimistic(options?: SafeCreateGroupOptions): WorkerConversation;
-    newGroupWithIdentifiers(identifiers: Identifier[], options?: SafeCreateGroupOptions): Promise<WorkerConversation>;
-    newGroup(inboxIds: string[], options?: SafeCreateGroupOptions): Promise<WorkerConversation>;
-    newDmWithIdentifier(identifier: Identifier, options?: SafeCreateDmOptions): Promise<WorkerConversation>;
-    newDm(inboxId: string, options?: SafeCreateDmOptions): Promise<WorkerConversation>;
-    getHmacKeys(): HmacKeys;
+    list(options?: ListConversationsOptions): WorkerConversation[];
+    listGroups(options?: Omit<ListConversationsOptions, "conversationType">): WorkerConversation[];
+    listDms(options?: Omit<ListConversationsOptions, "conversationType">): WorkerConversation[];
+    createGroupOptimistic(options?: CreateGroupOptions): WorkerConversation;
+    createGroupWithIdentifiers(identifiers: Identifier[], options?: CreateGroupOptions): Promise<WorkerConversation>;
+    createGroup(inboxIds: string[], options?: CreateGroupOptions): Promise<WorkerConversation>;
+    createDmWithIdentifier(identifier: Identifier, options?: CreateDmOptions): Promise<WorkerConversation>;
+    createDm(inboxId: string, options?: CreateDmOptions): Promise<WorkerConversation>;
+    hmacKeys(): HmacKeys;
     stream(callback: StreamCallback<Conversation$1>, onFail: () => void, conversationType?: ConversationType): _xmtp_wasm_bindings.StreamCloser;
     streamGroups(callback: StreamCallback<Conversation$1>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
     streamDms(callback: StreamCallback<Conversation$1>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
@@ -266,12 +315,11 @@ declare class WorkerConversations {
  */
 declare class WorkerDebugInformation {
     #private;
-    constructor(client: Client$1, options?: ClientOptions);
+    constructor(client: Client$1);
     apiStatistics(): _xmtp_wasm_bindings.ApiStats;
     apiIdentityStatistics(): _xmtp_wasm_bindings.IdentityStats;
     apiAggregateStatistics(): string;
     clearAllStatistics(): void;
-    uploadDebugArchive(serverUrl?: string): Promise<string>;
 }
 
 declare class WorkerPreferences {
@@ -279,17 +327,16 @@ declare class WorkerPreferences {
     constructor(client: Client$1, conversations: Conversations$1);
     sync(): Promise<_xmtp_wasm_bindings.GroupSyncSummary>;
     inboxState(refreshFromNetwork: boolean): Promise<_xmtp_wasm_bindings.InboxState>;
-    inboxStateFromInboxIds(inboxIds: string[], refreshFromNetwork?: boolean): Promise<_xmtp_wasm_bindings.InboxState[]>;
-    getLatestInboxState(inboxId: string): Promise<_xmtp_wasm_bindings.InboxState>;
-    setConsentStates(records: SafeConsent[]): Promise<void>;
+    getInboxStates(inboxIds: string[], refreshFromNetwork?: boolean): Promise<_xmtp_wasm_bindings.InboxState[]>;
+    setConsentStates(records: Consent[]): Promise<void>;
     getConsentState(entityType: ConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.ConsentState>;
     streamConsent(callback: StreamCallback<Consent[]>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
-    streamPreferences(callback: StreamCallback<UserPreference[]>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
+    streamPreferences(callback: StreamCallback<UserPreferenceUpdate[]>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
 }
 
 declare class WorkerClient {
     #private;
-    constructor(client: Client$1, options?: ClientOptions);
+    constructor(client: Client$1);
     static create(identifier: Identifier, options?: Omit<ClientOptions, "codecs">): Promise<WorkerClient>;
     get libxmtpVersion(): string;
     get appVersion(): string;
@@ -312,16 +359,16 @@ declare class WorkerClient {
     revokeInstallationsSignatureRequest(installationIds: Uint8Array[]): Promise<SignatureRequestHandle>;
     changeRecoveryIdentifierSignatureRequest(identifier: Identifier): Promise<SignatureRequestHandle>;
     registerIdentity(signer: SafeSigner, signatureRequest: SignatureRequestHandle): Promise<void>;
-    findInboxIdByIdentifier(identifier: Identifier): Promise<string | undefined>;
+    getInboxIdByIdentifier(identifier: Identifier): Promise<string | undefined>;
     signWithInstallationKey(signatureText: string): Uint8Array<ArrayBufferLike>;
     verifySignedWithInstallationKey(signatureText: string, signatureBytes: Uint8Array): boolean;
     verifySignedWithPublicKey(signatureText: string, signatureBytes: Uint8Array, publicKey: Uint8Array): boolean;
-    getKeyPackageStatusesForInstallationIds(installationIds: string[]): Promise<Map<string, KeyPackageStatus>>;
+    fetchKeyPackageStatuses(installationIds: string[]): Promise<Map<string, KeyPackageStatus>>;
 }
 
 declare class WorkerConversation {
     #private;
-    constructor(client: WorkerClient, group: Conversation$1, isCommitLogForked?: boolean);
+    constructor(client: WorkerClient, group: Conversation$1);
     get id(): string;
     get name(): string;
     updateName(name: string): Promise<void>;
@@ -332,18 +379,14 @@ declare class WorkerConversation {
     get appData(): string;
     updateAppData(appData: string): Promise<void>;
     get isActive(): boolean;
-    get isCommitLogForked(): boolean | undefined;
     get addedByInboxId(): string;
     get createdAtNs(): bigint;
-    lastMessage(): Promise<Message | undefined>;
-    metadata(): Promise<{
-        creatorInboxId: string;
-        conversationType: string;
-    }>;
-    members(): Promise<SafeGroupMember[]>;
-    get admins(): string[];
-    get superAdmins(): string[];
-    get permissions(): {
+    lastMessage(): Promise<DecodedMessage$1 | undefined>;
+    metadata(): Promise<_xmtp_wasm_bindings.GroupMetadata>;
+    members(): Promise<GroupMember[]>;
+    listAdmins(): string[];
+    listSuperAdmins(): string[];
+    permissions(): {
         policyType: _xmtp_wasm_bindings.GroupPermissionsOptions;
         policySet: _xmtp_wasm_bindings.PermissionPolicySet;
     };
@@ -360,11 +403,22 @@ declare class WorkerConversation {
     addSuperAdmin(inboxId: string): Promise<void>;
     removeSuperAdmin(inboxId: string): Promise<void>;
     publishMessages(): Promise<void>;
-    sendOptimistic(encodedContent: EncodedContent, opts: SendMessageOpts): string;
-    send(encodedContent: EncodedContent, opts: SendMessageOpts): Promise<string>;
-    messages(options?: SafeListMessagesOptions): Promise<Message[]>;
-    countMessages(options?: SafeListMessagesOptions): Promise<bigint>;
-    get consentState(): ConsentState;
+    send(encodedContent: EncodedContent, opts?: SendMessageOpts): Promise<string>;
+    sendText(text: string, isOptimistic?: boolean): Promise<string>;
+    sendMarkdown(markdown: string, isOptimistic?: boolean): Promise<string>;
+    sendReaction(reaction: Reaction, isOptimistic?: boolean): Promise<string>;
+    sendReadReceipt(isOptimistic?: boolean): Promise<string>;
+    sendReply(reply: Reply, isOptimistic?: boolean): Promise<string>;
+    sendTransactionReference(transactionReference: TransactionReference, isOptimistic?: boolean): Promise<string>;
+    sendWalletSendCalls(walletSendCalls: WalletSendCalls, isOptimistic?: boolean): Promise<string>;
+    sendActions(actions: Actions, isOptimistic?: boolean): Promise<string>;
+    sendIntent(intent: Intent, isOptimistic?: boolean): Promise<string>;
+    sendAttachment(attachment: Attachment, isOptimistic?: boolean): Promise<string>;
+    sendMultiRemoteAttachment(multiRemoteAttachment: MultiRemoteAttachment, isOptimistic?: boolean): Promise<string>;
+    sendRemoteAttachment(remoteAttachment: RemoteAttachment, isOptimistic?: boolean): Promise<string>;
+    messages(options?: ListMessagesOptions): Promise<DecodedMessage$1[]>;
+    countMessages(options?: ListMessagesOptions): Promise<bigint>;
+    consentState(): ConsentState;
     updateConsentState(state: ConsentState): void;
     dmPeerInboxId(): string;
     messageDisappearingSettings(): MessageDisappearingSettings | undefined;
@@ -373,103 +427,14 @@ declare class WorkerConversation {
     isMessageDisappearingEnabled(): boolean;
     stream(callback: StreamCallback<Message>, onFail: () => void): _xmtp_wasm_bindings.StreamCloser;
     pausedForVersion(): string | undefined;
-    getHmacKeys(): Map<string, HmacKey[]>;
+    hmacKeys(): Map<string, HmacKey[]>;
     debugInfo(): Promise<ConversationDebugInfo>;
-    getDuplicateDms(): Promise<WorkerConversation[]>;
+    duplicateDms(): Promise<WorkerConversation[]>;
     requestRemoval(): Promise<void>;
-    get isPendingRemoval(): boolean;
+    isPendingRemoval(): boolean;
+    lastReadTimes(): Promise<LastReadTimes>;
 }
 
-declare const toContentTypeId: (contentTypeId: ContentTypeId) => ContentTypeId$1;
-declare const fromContentTypeId: (contentTypeId: ContentTypeId$1) => ContentTypeId;
-type SafeContentTypeId = {
-    authorityId: string;
-    typeId: string;
-    versionMajor: number;
-    versionMinor: number;
-};
-declare const toSafeContentTypeId: (contentTypeId: ContentTypeId$1) => SafeContentTypeId;
-declare const fromSafeContentTypeId: (contentTypeId: SafeContentTypeId) => ContentTypeId$1;
-declare const toEncodedContent: (content: EncodedContent) => EncodedContent$1;
-declare const fromEncodedContent: (content: EncodedContent$1) => EncodedContent;
-type SafeEncodedContent = {
-    type: SafeContentTypeId;
-    parameters: Record<string, string>;
-    fallback?: string;
-    compression?: number;
-    content: Uint8Array;
-};
-declare const toSafeEncodedContent: (content: EncodedContent$1) => SafeEncodedContent;
-declare const fromSafeEncodedContent: (content: SafeEncodedContent) => EncodedContent$1;
-type SafeMessage = {
-    content: SafeEncodedContent;
-    convoId: string;
-    deliveryStatus: DeliveryStatus;
-    id: string;
-    kind: GroupMessageKind;
-    senderInboxId: string;
-    sentAtNs: bigint;
-};
-declare const toSafeMessage: (message: Message) => SafeMessage;
-type SafeListMessagesOptions = {
-    contentTypes?: ContentType[];
-    deliveryStatus?: DeliveryStatus;
-    direction?: SortDirection;
-    excludeContentTypes?: ContentType[];
-    excludeSenderInboxIds?: string[];
-    insertedAfterNs?: bigint;
-    insertedBeforeNs?: bigint;
-    kind?: GroupMessageKind;
-    limit?: bigint;
-    sentAfterNs?: bigint;
-    sentBeforeNs?: bigint;
-    sortBy?: MessageSortBy;
-};
-declare const toSafeListMessagesOptions: (options: ListMessagesOptions) => SafeListMessagesOptions;
-declare const fromSafeListMessagesOptions: (options: SafeListMessagesOptions) => ListMessagesOptions;
-type SafeSendMessageOpts = {
-    shouldPush: boolean;
-};
-declare const toSafeSendMessageOpts: (opts: SendMessageOpts) => SafeSendMessageOpts;
-declare const fromSafeSendMessageOpts: (opts: SafeSendMessageOpts) => SendMessageOpts;
-type SafeListConversationsOptions = {
-    consentStates?: ConsentState[];
-    conversationType?: ConversationType;
-    createdAfterNs?: bigint;
-    createdBeforeNs?: bigint;
-    includeDuplicateDms?: boolean;
-    limit?: bigint;
-    orderBy?: ListConversationsOrderBy;
-};
-declare const toSafeListConversationsOptions: (options: ListConversationsOptions) => SafeListConversationsOptions;
-declare const fromSafeListConversationsOptions: (options: SafeListConversationsOptions) => ListConversationsOptions;
-type SafePermissionPolicySet = {
-    addAdminPolicy: PermissionPolicy;
-    addMemberPolicy: PermissionPolicy;
-    removeAdminPolicy: PermissionPolicy;
-    removeMemberPolicy: PermissionPolicy;
-    updateGroupDescriptionPolicy: PermissionPolicy;
-    updateGroupImageUrlSquarePolicy: PermissionPolicy;
-    updateGroupNamePolicy: PermissionPolicy;
-    updateMessageDisappearingPolicy: PermissionPolicy;
-};
-declare const toSafePermissionPolicySet: (policySet: PermissionPolicySet) => SafePermissionPolicySet;
-declare const fromSafePermissionPolicySet: (policySet: SafePermissionPolicySet) => PermissionPolicySet;
-type SafeCreateGroupOptions = {
-    customPermissionPolicySet?: SafePermissionPolicySet;
-    description?: string;
-    imageUrlSquare?: string;
-    messageDisappearingSettings?: SafeMessageDisappearingSettings;
-    name?: string;
-    permissions?: GroupPermissionsOptions;
-};
-declare const toSafeCreateGroupOptions: (options: CreateGroupOptions) => SafeCreateGroupOptions;
-declare const fromSafeCreateGroupOptions: (options: SafeCreateGroupOptions) => CreateGroupOptions;
-type SafeCreateDmOptions = {
-    messageDisappearingSettings?: SafeMessageDisappearingSettings;
-};
-declare const toSafeCreateDmOptions: (options: CreateDMOptions) => SafeCreateDmOptions;
-declare const fromSafeCreateDmOptions: (options: SafeCreateDmOptions) => CreateDMOptions;
 type SafeConversation = {
     id: string;
     name: string;
@@ -478,118 +443,27 @@ type SafeConversation = {
     appData: string;
     permissions: {
         policyType: GroupPermissionsOptions;
-        policySet: {
-            addAdminPolicy: PermissionPolicy;
-            addMemberPolicy: PermissionPolicy;
-            removeAdminPolicy: PermissionPolicy;
-            removeMemberPolicy: PermissionPolicy;
-            updateGroupDescriptionPolicy: PermissionPolicy;
-            updateGroupImageUrlSquarePolicy: PermissionPolicy;
-            updateGroupNamePolicy: PermissionPolicy;
-            updateMessageDisappearingPolicy: PermissionPolicy;
-        };
+        policySet: PermissionPolicySet;
     };
     addedByInboxId: string;
-    metadata: {
-        creatorInboxId: string;
-        conversationType: string;
-    };
+    metadata: GroupMetadata;
     admins: string[];
     superAdmins: string[];
     createdAtNs: bigint;
-    isCommitLogForked?: boolean;
 };
 declare const toSafeConversation: (conversation: WorkerConversation) => Promise<SafeConversation>;
-type SafeInstallation = {
-    bytes: Uint8Array;
-    clientTimestampNs?: bigint;
-    id: string;
-};
-declare const toSafeInstallation: (installation: Installation) => SafeInstallation;
-type SafeInboxState = {
-    identifiers: Identifier[];
-    inboxId: string;
-    installations: SafeInstallation[];
-    recoveryIdentifier: Identifier;
-};
-declare const toSafeInboxState: (inboxState: InboxState) => SafeInboxState;
-type SafeConsent = {
-    entity: string;
-    entityType: ConsentEntityType;
-    state: ConsentState;
-};
-declare const toSafeConsent: (consent: Consent) => SafeConsent;
-declare const fromSafeConsent: (consent: SafeConsent) => Consent;
-type SafeGroupMember = {
-    accountIdentifiers: Identifier[];
-    consentState: ConsentState;
-    inboxId: string;
-    installationIds: string[];
-    permissionLevel: PermissionLevel;
-};
-declare const toSafeGroupMember: (member: GroupMember) => SafeGroupMember;
-declare const fromSafeGroupMember: (member: SafeGroupMember) => GroupMember;
-type SafeHmacKey = {
-    key: Uint8Array;
-    epoch: bigint;
-};
-declare const toSafeHmacKey: (hmacKey: HmacKey) => SafeHmacKey;
 type HmacKeys = Map<string, HmacKey[]>;
-type SafeHmacKeys = Record<string, SafeHmacKey[]>;
-type SafeMessageDisappearingSettings = {
-    fromNs: bigint;
-    inNs: bigint;
-};
-declare const toSafeMessageDisappearingSettings: (settings: MessageDisappearingSettings) => SafeMessageDisappearingSettings;
-declare const fromSafeMessageDisappearingSettings: (settings: SafeMessageDisappearingSettings) => MessageDisappearingSettings;
-type SafeKeyPackageStatus = {
-    lifetime?: {
-        notBefore: bigint;
-        notAfter: bigint;
-    };
-    validationError?: string;
-};
-declare const toSafeKeyPackageStatus: (status: KeyPackageStatus) => SafeKeyPackageStatus;
-type SafeXMTPCursor = {
-    originatorID: number;
-    sequenceID: bigint;
-};
-type SafeConversationDebugInfo = {
-    epoch: bigint;
-    maybeForked: boolean;
-    forkDetails: string;
-    isCommitLogForked?: boolean;
-    localCommitLog: string;
-    remoteCommitLog: string;
-    cursor: SafeXMTPCursor[];
-};
-declare const toSafeConversationDebugInfo: (debugInfo: ConversationDebugInfo) => SafeConversationDebugInfo;
-type SafeApiStats = {
-    fetchKeyPackage: bigint;
-    queryGroupMessages: bigint;
-    queryWelcomeMessages: bigint;
-    sendGroupMessages: bigint;
-    sendWelcomeMessages: bigint;
-    subscribeMessages: bigint;
-    subscribeWelcomes: bigint;
-    uploadKeyPackage: bigint;
-};
-declare const toSafeApiStats: (stats: ApiStats) => SafeApiStats;
-type SafeIdentityStats = {
-    getIdentityUpdatesV2: bigint;
-    getInboxIds: bigint;
-    publishIdentityUpdate: bigint;
-    verifySmartContractWalletSignature: bigint;
-};
-declare const toSafeIdentityStats: (stats: IdentityStats) => SafeIdentityStats;
+type LastReadTimes = Map<string, bigint>;
 
 type ClientAction = {
     action: "client.init";
     id: string;
     result: {
+        appVersion: string;
         inboxId: string;
         installationId: string;
         installationIdBytes: Uint8Array;
+        libxmtpVersion: string;
     };
     data: {
         identifier: Identifier;
@@ -732,7 +606,7 @@ type ClientAction = {
         identifiers: Identifier[];
     };
 } | {
-    action: "client.findInboxIdByIdentifier";
+    action: "client.getInboxIdByIdentifier";
     id: string;
     result: string | undefined;
     data: {
@@ -763,22 +637,12 @@ type ClientAction = {
         publicKey: Uint8Array;
     };
 } | {
-    action: "client.getKeyPackageStatusesForInstallationIds";
+    action: "client.fetchKeyPackageStatuses";
     id: string;
-    result: Map<string, SafeKeyPackageStatus>;
+    result: Map<string, KeyPackageStatus>;
     data: {
         installationIds: string[];
     };
-} | {
-    action: "client.libxmtpVersion";
-    id: string;
-    result: string;
-    data: undefined;
-} | {
-    action: "client.appVersion";
-    id: string;
-    result: string;
-    data: undefined;
 };
 
 type ConversationAction = {
@@ -794,17 +658,8 @@ type ConversationAction = {
     result: string;
     data: {
         id: string;
-        content: SafeEncodedContent;
-        sendOptions: SafeSendMessageOpts;
-    };
-} | {
-    action: "conversation.sendOptimistic";
-    id: string;
-    result: string;
-    data: {
-        id: string;
-        content: SafeEncodedContent;
-        sendOptions: SafeSendMessageOpts;
+        content: EncodedContent;
+        options?: SendMessageOpts;
     };
 } | {
     action: "conversation.publishMessages";
@@ -816,10 +671,10 @@ type ConversationAction = {
 } | {
     action: "conversation.messages";
     id: string;
-    result: SafeMessage[];
+    result: DecodedMessage$1[];
     data: {
         id: string;
-        options?: SafeListMessagesOptions;
+        options?: ListMessagesOptions;
     };
 } | {
     action: "conversation.countMessages";
@@ -827,19 +682,19 @@ type ConversationAction = {
     result: bigint;
     data: {
         id: string;
-        options?: Omit<SafeListMessagesOptions, "limit" | "direction">;
+        options?: Omit<ListMessagesOptions, "limit" | "direction">;
     };
 } | {
     action: "conversation.members";
     id: string;
-    result: SafeGroupMember[];
+    result: GroupMember[];
     data: {
         id: string;
     };
 } | {
     action: "conversation.messageDisappearingSettings";
     id: string;
-    result: SafeMessageDisappearingSettings | undefined;
+    result: MessageDisappearingSettings | undefined;
     data: {
         id: string;
     };
@@ -847,7 +702,7 @@ type ConversationAction = {
     action: "conversation.updateMessageDisappearingSettings";
     id: string;
     result: undefined;
-    data: SafeMessageDisappearingSettings & {
+    data: MessageDisappearingSettings & {
         id: string;
     };
 } | {
@@ -880,16 +735,16 @@ type ConversationAction = {
         id: string;
     };
 } | {
-    action: "conversation.getHmacKeys";
+    action: "conversation.hmacKeys";
     id: string;
-    result: Map<string, SafeHmacKey[]>;
+    result: HmacKeys;
     data: {
         id: string;
     };
 } | {
     action: "conversation.debugInfo";
     id: string;
-    result: SafeConversationDebugInfo;
+    result: ConversationDebugInfo;
     data: {
         id: string;
     };
@@ -911,7 +766,7 @@ type ConversationAction = {
 } | {
     action: "conversation.lastMessage";
     id: string;
-    result: SafeMessage | undefined;
+    result: DecodedMessage$1 | undefined;
     data: {
         id: string;
     };
@@ -922,6 +777,120 @@ type ConversationAction = {
     data: {
         id: string;
     };
+} | {
+    action: "conversation.lastReadTimes";
+    id: string;
+    result: LastReadTimes;
+    data: {
+        id: string;
+    };
+} | {
+    action: "conversation.sendText";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        text: string;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendMarkdown";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        markdown: string;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendReaction";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        reaction: Reaction;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendReadReceipt";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendReply";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        reply: Reply;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendTransactionReference";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        transactionReference: TransactionReference;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendWalletSendCalls";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        walletSendCalls: WalletSendCalls;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendActions";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        actions: Actions;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendIntent";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        intent: Intent;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendAttachment";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        attachment: Attachment;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendMultiRemoteAttachment";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        multiRemoteAttachment: MultiRemoteAttachment;
+        isOptimistic?: boolean;
+    };
+} | {
+    action: "conversation.sendRemoteAttachment";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        remoteAttachment: RemoteAttachment;
+        isOptimistic?: boolean;
+    };
 };
 
 type ConversationsAction = {
@@ -934,7 +903,7 @@ type ConversationsAction = {
 } | {
     action: "conversations.getMessageById";
     id: string;
-    result: SafeMessage | undefined;
+    result: DecodedMessage$1 | undefined;
     data: {
         id: string;
     };
@@ -950,60 +919,60 @@ type ConversationsAction = {
     id: string;
     result: SafeConversation[];
     data: {
-        options?: SafeListConversationsOptions;
+        options?: ListConversationsOptions;
     };
 } | {
     action: "conversations.listGroups";
     id: string;
     result: SafeConversation[];
     data: {
-        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+        options?: Omit<ListConversationsOptions, "conversationType">;
     };
 } | {
     action: "conversations.listDms";
     id: string;
     result: SafeConversation[];
     data: {
-        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+        options?: Omit<ListConversationsOptions, "conversationType">;
     };
 } | {
-    action: "conversations.newGroupOptimistic";
+    action: "conversations.createGroupOptimistic";
     id: string;
     result: SafeConversation;
     data: {
-        options?: SafeCreateGroupOptions;
+        options?: CreateGroupOptions;
     };
 } | {
-    action: "conversations.newGroupWithIdentifiers";
+    action: "conversations.createGroupWithIdentifiers";
     id: string;
     result: SafeConversation;
     data: {
         identifiers: Identifier[];
-        options?: SafeCreateGroupOptions;
+        options?: CreateGroupOptions;
     };
 } | {
-    action: "conversations.newGroup";
+    action: "conversations.createGroup";
     id: string;
     result: SafeConversation;
     data: {
         inboxIds: string[];
-        options?: SafeCreateGroupOptions;
+        options?: CreateGroupOptions;
     };
 } | {
-    action: "conversations.newDmWithIdentifier";
+    action: "conversations.createDmWithIdentifier";
     id: string;
     result: SafeConversation;
     data: {
         identifier: Identifier;
-        options?: SafeCreateDmOptions;
+        options?: CreateDmOptions;
     };
 } | {
-    action: "conversations.newDm";
+    action: "conversations.createDm";
     id: string;
     result: SafeConversation;
     data: {
         inboxId: string;
-        options?: SafeCreateDmOptions;
+        options?: CreateDmOptions;
     };
 } | {
     action: "conversations.sync";
@@ -1018,9 +987,9 @@ type ConversationsAction = {
         consentStates?: ConsentState[];
     };
 } | {
-    action: "conversations.getHmacKeys";
+    action: "conversations.hmacKeys";
     id: string;
-    result: SafeHmacKeys;
+    result: HmacKeys;
     data: undefined;
 } | {
     action: "conversations.stream";
@@ -1051,12 +1020,12 @@ type ConversationsAction = {
 type DebugInformationAction = {
     action: "debugInformation.apiStatistics";
     id: string;
-    result: SafeApiStats;
+    result: ApiStats;
     data: undefined;
 } | {
     action: "debugInformation.apiIdentityStatistics";
     id: string;
-    result: SafeIdentityStats;
+    result: IdentityStats;
     data: undefined;
 } | {
     action: "debugInformation.apiAggregateStatistics";
@@ -1068,13 +1037,6 @@ type DebugInformationAction = {
     id: string;
     result: undefined;
     data: undefined;
-} | {
-    action: "debugInformation.uploadDebugArchive";
-    id: string;
-    result: string;
-    data: {
-        serverUrl?: string;
-    };
 };
 
 type DmAction = {
@@ -1085,7 +1047,7 @@ type DmAction = {
         id: string;
     };
 } | {
-    action: "dm.getDuplicateDms";
+    action: "dm.duplicateDms";
     id: string;
     result: SafeConversation[];
     data: {
@@ -1255,31 +1217,24 @@ type GroupAction = {
 type PreferencesAction = {
     action: "preferences.inboxState";
     id: string;
-    result: SafeInboxState;
+    result: InboxState;
     data: {
         refreshFromNetwork: boolean;
     };
 } | {
-    action: "preferences.inboxStateFromInboxIds";
+    action: "preferences.getInboxStates";
     id: string;
-    result: SafeInboxState[];
+    result: InboxState[];
     data: {
         inboxIds: string[];
         refreshFromNetwork: boolean;
     };
-} | {
-    action: "preferences.getLatestInboxState";
-    id: string;
-    result: SafeInboxState;
-    data: {
-        inboxId: string;
-    };
 } | {
     action: "preferences.setConsentStates";
     id: string;
     result: undefined;
     data: {
-        records: SafeConsent[];
+        records: Consent[];
     };
 } | {
     action: "preferences.getConsentState";
@@ -1316,14 +1271,15 @@ type UnknownAction = {
     result: unknown;
     data: unknown;
 };
-type ClientWorkerAction = {
+type EndStreamAction = {
     action: "endStream";
     id: string;
     result: undefined;
     data: {
         streamId: string;
     };
-} | ClientAction | ConversationAction | ConversationsAction | DmAction | GroupAction | PreferencesAction | DebugInformationAction;
+};
+type ClientWorkerAction = EndStreamAction | ClientAction | ConversationAction | ConversationsAction | DmAction | GroupAction | PreferencesAction | DebugInformationAction;
 type ActionName<T extends UnknownAction> = T["action"];
 type ExtractAction<T extends UnknownAction, A extends ActionName<T>> = Extract<T, {
     action: A;
@@ -1344,7 +1300,7 @@ type ActionErrorData<T extends UnknownAction> = {
 type StreamAction = {
     action: "stream.message";
     streamId: string;
-    result: SafeMessage | undefined;
+    result: DecodedMessage$1 | undefined;
 } | {
     action: "stream.conversation";
     streamId: string;
@@ -1352,11 +1308,11 @@ type StreamAction = {
 } | {
     action: "stream.consent";
     streamId: string;
-    result: SafeConsent[] | undefined;
+    result: Consent[] | undefined;
 } | {
     action: "stream.preferences";
     streamId: string;
-    result: UserPreference[] | undefined;
+    result: UserPreferenceUpdate[] | undefined;
 } | {
     action: "stream.messageDeleted";
     streamId: string;
@@ -1368,85 +1324,45 @@ type StreamAction = {
 };
 
 /**
- * Class that sets up a worker and provides communications for client functions
+ * Class that sets up a bridge for worker communications
  *
- * This class is not meant to be used directly, it is extended by the Client class
- * to provide an interface to the worker.
+ * This class is not meant to be used directly.
  *
- * @param worker - The worker to use for the client class
+ * @param worker - The worker to use for communications
  * @param enableLogging - Whether to enable logging in the worker
- * @returns A new ClientWorkerClass instance
+ * @returns A new WorkerBridge instance
  */
-declare class ClientWorkerClass {
+declare class WorkerBridge<T extends UnknownAction> {
     #private;
-    constructor(worker: Worker, enableLogging: boolean);
+    constructor(worker: Worker, enableLogging?: boolean);
     /**
-     * Sends an action message to the client worker
+     * Sends an action message to the worker
      *
      * @param action - The action to send to the worker
      * @param data - The data to send to the worker
      * @returns A promise that resolves when the action is completed
      */
-    sendMessage<A extends ActionName<ClientWorkerAction>>(action: A, data: ExtractActionData<ClientWorkerAction, A>): [ExtractActionResult<ClientWorkerAction, A>] extends [undefined] ? Promise<void> : Promise<ExtractActionResult<ClientWorkerAction, A>>;
+    action<A extends ActionName<T>, D = ExtractActionData<T, A>, R = ExtractActionResult<T, A>>(action: A, ...args: D extends undefined ? [] : [data: D]): [R] extends [undefined] ? Promise<void> : Promise<R>;
     /**
-     * Handles a message from the client worker
+     * Handles a message from the worker
      *
      * @param event - The event to handle
      */
-    handleMessage: (event: MessageEvent<ActionWithoutData<ClientWorkerAction> | ActionErrorData<ClientWorkerAction>>) => void;
+    handleMessage: (event: MessageEvent<ActionWithoutData<T> | ActionErrorData<T>>) => void;
     /**
-     * Handles a stream message from the client worker
+     * Handles a stream message from the worker
      *
      * @param streamId - The ID of the stream to handle
      * @param callback - The callback to handle the stream message
      * @returns A function to remove the stream handler
      */
-    handleStreamMessage: <T extends StreamAction["result"], V = T>(streamId: string, callback: (error: Error | null, value: T | undefined) => void, options?: StreamOptions<T, V>) => () => Promise<void>;
+    handleStreamMessage: <R extends StreamAction["result"], V = R>(streamId: string, callback: (error: Error | null, value: R | undefined) => void, options?: StreamOptions<R, V>) => () => Promise<void>;
     /**
      * Removes all event listeners and terminates the worker
      */
     close(): void;
 }
 
-type MessageKind = "application" | "membership_change";
-type MessageDeliveryStatus = "unpublished" | "published" | "failed";
-/**
- * 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 {Map<string, string>} parameters - Additional parameters associated with the message
- * @property {SafeMessage["content"]} encodedContent - Raw encoded content of the message
- * @property {string} senderInboxId - Identifier for the sender's inbox
- * @property {bigint} sentAtNs - Timestamp when the message was sent (in nanoseconds)
- */
-declare class DecodedMessage<ContentTypes = unknown> {
-    #private;
-    content: ContentTypes | undefined;
-    contentType: ContentTypeId$1;
-    conversationId: string;
-    deliveryStatus: MessageDeliveryStatus;
-    fallback?: string;
-    compression?: number;
-    id: string;
-    kind: MessageKind;
-    parameters: Map<string, string>;
-    encodedContent: SafeMessage["content"];
-    senderInboxId: string;
-    sentAtNs: bigint;
-    constructor(client: Client<ContentTypes>, message: SafeMessage);
-}
-
 /**
  * Represents a conversation
  *
@@ -1457,20 +1373,17 @@ declare class Conversation<ContentTypes = unknown> {
     /**
      * Creates a new conversation instance
      *
-     * @param client - The client instance managing the conversation
+     * @param worker - The worker bridge instance for client communication
+     * @param codecRegistry - The codec registry instance
      * @param id - The unique identifier for this conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client<ContentTypes>, id: string, data?: SafeConversation);
+    constructor(worker: WorkerBridge<ClientWorkerAction>, codecRegistry: CodecRegistry, id: string, data?: SafeConversation);
     get id(): string;
-    get isCommitLogForked(): boolean | undefined;
     get addedByInboxId(): string | undefined;
     get createdAtNs(): bigint | undefined;
     get createdAt(): Date | undefined;
-    get metadata(): {
-        creatorInboxId: string;
-        conversationType: string;
-    } | undefined;
+    get metadata(): _xmtp_wasm_bindings.GroupMetadata | undefined;
     lastMessage(): Promise<DecodedMessage<ContentTypes> | undefined>;
     isActive(): Promise<boolean>;
     /**
@@ -1478,7 +1391,7 @@ declare class Conversation<ContentTypes = unknown> {
      *
      * @returns Promise that resolves with the conversation members
      */
-    members(): Promise<SafeGroupMember[]>;
+    members(): Promise<_xmtp_wasm_bindings.GroupMember[]>;
     /**
      * Synchronizes conversation data from the network
      *
@@ -1492,37 +1405,126 @@ declare class Conversation<ContentTypes = unknown> {
      */
     publishMessages(): Promise<void>;
     /**
-     * Prepares a message to be published
+     * Sends a message
+     *
+     * @param content - The encoded content to send
+     * @param options - Optional send options
+     * @param options.shouldPush - Indicates whether this message should be
+     * included in push notifications
+     * @param options.isOptimistic - Indicates whether this message should be
+     * sent optimistically and published later via `publishMessages`
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    send(content: EncodedContent, options?: SendMessageOpts): Promise<string>;
+    /**
+     * Sends a text message
+     *
+     * @param text - The text to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendText(text: string, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a markdown message
+     *
+     * @param markdown - The markdown to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendMarkdown(markdown: string, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a reaction message
+     *
+     * @param reaction - The reaction to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendReaction(reaction: Reaction, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a read receipt message
+     *
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendReadReceipt(isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a reply message
+     *
+     * @param reply - The reply to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendReply(reply: Reply, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a transaction reference message
+     *
+     * @param transactionReference - The transaction reference to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendTransactionReference(transactionReference: TransactionReference, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a wallet send calls message
+     *
+     * @param walletSendCalls - The wallet send calls to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendWalletSendCalls(walletSendCalls: WalletSendCalls, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends an actions message
+     *
+     * @param actions - The actions to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendActions(actions: Actions, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends an intent message
+     *
+     * @param intent - The intent to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendIntent(intent: Intent, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends an attachment message
+     *
+     * @param attachment - The attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    sendAttachment(attachment: Attachment, isOptimistic?: boolean): Promise<string>;
+    /**
+     * Sends a multi remote attachment message
      *
-     * @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
+     * @param multiRemoteAttachment - The multi remote attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
      */
-    sendOptimistic(content: ContentTypes, contentType?: ContentTypeId$1): Promise<string>;
+    sendMultiRemoteAttachment(multiRemoteAttachment: MultiRemoteAttachment, isOptimistic?: boolean): Promise<string>;
     /**
-     * Publishes a new message
+     * Sends a remote attachment message
      *
-     * @param content - The content to send
-     * @param contentType - Optional content type of the message content
+     * @param remoteAttachment - The remote attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
      * @returns Promise that resolves with the message ID after it has been sent
-     * @throws {MissingContentTypeError} if content type is required but not provided
      */
-    send(content: ContentTypes, contentType?: ContentTypeId$1): Promise<string>;
+    sendRemoteAttachment(remoteAttachment: RemoteAttachment, isOptimistic?: boolean): Promise<string>;
     /**
      * Lists messages in this conversation
      *
      * @param options - Optional filtering and pagination options
      * @returns Promise that resolves with an array of decoded messages
      */
-    messages(options?: SafeListMessagesOptions): Promise<DecodedMessage<ContentTypes>[]>;
+    messages(options?: ListMessagesOptions): Promise<DecodedMessage<ContentTypes>[]>;
     /**
      * Counts messages in this conversation
      *
      * @param options - Optional filtering options
      * @returns Promise that resolves with the count of messages
      */
-    countMessages(options?: Omit<SafeListMessagesOptions, "limit" | "direction">): Promise<bigint>;
+    countMessages(options?: Omit<ListMessagesOptions, "limit" | "direction">): Promise<bigint>;
     /**
      * Gets the consent state for this conversation
      *
@@ -1541,7 +1543,7 @@ declare class Conversation<ContentTypes = unknown> {
      *
      * @returns Promise that resolves with the current message disappearing settings
      */
-    messageDisappearingSettings(): Promise<SafeMessageDisappearingSettings | undefined>;
+    messageDisappearingSettings(): Promise<_xmtp_wasm_bindings.MessageDisappearingSettings | undefined>;
     /**
      * Updates message disappearing settings for this conversation
      *
@@ -1568,20 +1570,27 @@ declare class Conversation<ContentTypes = unknown> {
      * @param callback - Optional callback function for handling new stream values
      * @returns Stream instance for new messages
      */
-    stream(options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>>): Promise<AsyncStreamProxy<DecodedMessage<ContentTypes>>>;
+    stream(options?: StreamOptions<DecodedMessage$1, DecodedMessage<ContentTypes>>): Promise<AsyncStreamProxy<DecodedMessage<ContentTypes>>>;
     pausedForVersion(): Promise<string | undefined>;
     /**
-     * Retrieves HMAC keys for this conversation
+     * Gets HMAC keys for this conversation
      *
      * @returns Promise that resolves with the HMAC keys
      */
-    getHmacKeys(): Promise<Map<string, SafeHmacKey[]>>;
+    hmacKeys(): Promise<HmacKeys>;
     /**
      * Retrieves information for this conversation to help with debugging
      *
      * @returns The debug information for this conversation
      */
-    debugInfo(): Promise<SafeConversationDebugInfo>;
+    debugInfo(): Promise<_xmtp_wasm_bindings.ConversationDebugInfo>;
+    /**
+     * Retrieves the last read times for this conversation
+     *
+     * @returns A map keyed by inbox ID with the last read timestamp
+     * (nanoseconds since epoch)
+     */
+    lastReadTimes(): Promise<LastReadTimes>;
 }
 
 /**
@@ -1594,18 +1603,19 @@ declare class Dm<ContentTypes = unknown> extends Conversation<ContentTypes> {
     /**
      * Creates a new direct message conversation instance
      *
-     * @param client - The client instance managing this direct message conversation
+     * @param worker - The worker bridge instance for client communication
+     * @param codecRegistry - The codec registry instance
      * @param id - Identifier for the direct message conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client<ContentTypes>, id: string, data?: SafeConversation);
+    constructor(worker: WorkerBridge<ClientWorkerAction>, codecRegistry: CodecRegistry, id: string, data?: SafeConversation);
     /**
      * Retrieves the inbox ID of the other participant in the DM
      *
      * @returns Promise that resolves with the peer's inbox ID
      */
     peerInboxId(): Promise<string>;
-    getDuplicateDms(): Promise<SafeConversation[]>;
+    duplicateDms(): Promise<Dm<ContentTypes>[]>;
 }
 
 /**
@@ -1618,11 +1628,12 @@ declare class Group<ContentTypes = unknown> extends Conversation<ContentTypes> {
     /**
      * Creates a new group conversation instance
      *
-     * @param client - The client instance managing this group conversation
+     * @param worker - The worker bridge instance for client communication
+     * @param codecRegistry - The codec registry instance
      * @param id - Identifier for the group conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client<ContentTypes>, id: string, data?: SafeConversation);
+    constructor(worker: WorkerBridge<ClientWorkerAction>, codecRegistry: CodecRegistry, id: string, data?: SafeConversation);
     /**
      * Synchronizes the group's data with the network
      *
@@ -1696,16 +1707,7 @@ declare class Group<ContentTypes = unknown> extends Conversation<ContentTypes> {
      */
     permissions(): Promise<{
         policyType: _xmtp_wasm_bindings.GroupPermissionsOptions;
-        policySet: {
-            addAdminPolicy: PermissionPolicy;
-            addMemberPolicy: PermissionPolicy;
-            removeAdminPolicy: PermissionPolicy;
-            removeMemberPolicy: PermissionPolicy;
-            updateGroupDescriptionPolicy: PermissionPolicy;
-            updateGroupImageUrlSquarePolicy: PermissionPolicy;
-            updateGroupNamePolicy: PermissionPolicy;
-            updateMessageDisappearingPolicy: PermissionPolicy;
-        };
+        policySet: _xmtp_wasm_bindings.PermissionPolicySet;
     }>;
     /**
      * Updates a specific permission policy for the group
@@ -1799,9 +1801,10 @@ declare class Conversations<ContentTypes = unknown> {
     /**
      * Creates a new conversations instance
      *
-     * @param client - The client instance managing the conversations
+     * @param worker - The worker bridge instance for client communication
+     * @param codecRegistry - The codec registry instance
      */
-    constructor(client: Client<ContentTypes>);
+    constructor(worker: WorkerBridge<ClientWorkerAction>, codecRegistry: CodecRegistry);
     /**
      * Synchronizes conversations for the current client from the network
      *
@@ -1837,42 +1840,42 @@ declare class Conversations<ContentTypes = unknown> {
      * @param inboxId - The inbox ID to look up
      * @returns Promise that resolves with the DM, if found
      */
-    getDmByInboxId(inboxId: string): Promise<Dm<ContentTypes> | undefined>;
+    getDmByInboxId(inboxId: string): Promise<Dm<unknown> | undefined>;
     /**
-     * Retrieves a DM by identifier
+     * Fetches a DM by identifier
      *
      * @param identifier - The identifier to look up
      * @returns Promise that resolves with the DM, if found
      */
-    getDmByIdentifier(identifier: Identifier): Promise<Dm<ContentTypes> | undefined>;
+    fetchDmByIdentifier(identifier: Identifier): Promise<Dm<unknown> | undefined>;
     /**
      * Lists all conversations with optional filtering
      *
      * @param options - Optional filtering and pagination options
      * @returns Promise that resolves with an array of conversations
      */
-    list(options?: SafeListConversationsOptions): Promise<(Group<ContentTypes> | Dm<ContentTypes>)[]>;
+    list(options?: ListConversationsOptions): Promise<(Group<ContentTypes> | Dm<ContentTypes>)[]>;
     /**
      * Lists all group conversations with optional filtering
      *
      * @param options - Optional filtering and pagination options
      * @returns Promise that resolves with an array of groups
      */
-    listGroups(options?: Omit<SafeListConversationsOptions, "conversation_type">): Promise<Group<ContentTypes>[]>;
+    listGroups(options?: Omit<ListConversationsOptions, "conversationType">): Promise<Group<ContentTypes>[]>;
     /**
      * Lists all DM conversations with optional filtering
      *
      * @param options - Optional filtering and pagination options
      * @returns Promise that resolves with an array of DMs
      */
-    listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">): Promise<Dm<ContentTypes>[]>;
+    listDms(options?: Omit<ListConversationsOptions, "conversationType">): Promise<Dm<ContentTypes>[]>;
     /**
-     * Creates a new group without syncing to the network
+     * Creates a new group conversation without publishing to the network
      *
      * @param options - Optional group creation options
      * @returns Promise that resolves with the new group
      */
-    newGroupOptimistic(options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
+    createGroupOptimistic(options?: CreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new group conversation with the specified identifiers
      *
@@ -1880,7 +1883,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options - Optional group creation options
      * @returns Promise that resolves with the new group
      */
-    newGroupWithIdentifiers(identifiers: Identifier[], options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
+    createGroupWithIdentifiers(identifiers: Identifier[], options?: CreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new group conversation with the specified inbox IDs
      *
@@ -1888,7 +1891,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options - Optional group creation options
      * @returns Promise that resolves with the new group
      */
-    newGroup(inboxIds: string[], options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
+    createGroup(inboxIds: string[], options?: CreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new DM conversation with the specified identifier
      *
@@ -1896,7 +1899,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options - Optional DM creation options
      * @returns Promise that resolves with the new DM
      */
-    newDmWithIdentifier(identifier: Identifier, options?: SafeCreateDmOptions): Promise<Dm<ContentTypes>>;
+    createDmWithIdentifier(identifier: Identifier, options?: CreateDmOptions): Promise<Dm<ContentTypes>>;
     /**
      * Creates a new DM conversation with the specified inbox ID
      *
@@ -1904,13 +1907,13 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options - Optional DM creation options
      * @returns Promise that resolves with the new DM
      */
-    newDm(inboxId: string, options?: SafeCreateDmOptions): Promise<Dm<ContentTypes>>;
+    createDm(inboxId: string, options?: CreateDmOptions): Promise<Dm<ContentTypes>>;
     /**
-     * Retrieves HMAC keys for all conversations
+     * Gets the HMAC keys for all conversations
      *
      * @returns Promise that resolves with the HMAC keys for all conversations
      */
-    getHmacKeys(): Promise<SafeHmacKeys>;
+    hmacKeys(): Promise<HmacKeys>;
     /**
      * Creates a stream for new conversations
      *
@@ -1943,7 +1946,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options.consentStates - Optional consent states to filter messages
      * @returns Stream instance for new messages
      */
-    streamAllMessages(options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+    streamAllMessages(options?: StreamOptions<DecodedMessage$1, DecodedMessage<ContentTypes>> & {
         conversationType?: ConversationType;
         consentStates?: ConsentState[];
     }): Promise<AsyncStreamProxy<DecodedMessage<ContentTypes>>>;
@@ -1954,7 +1957,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options.consentStates - Optional consent states to filter messages
      * @returns Stream instance for new group messages
      */
-    streamAllGroupMessages(options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+    streamAllGroupMessages(options?: StreamOptions<DecodedMessage$1, DecodedMessage<ContentTypes>> & {
         consentStates?: ConsentState[];
     }): Promise<AsyncStreamProxy<DecodedMessage<ContentTypes>>>;
     /**
@@ -1964,7 +1967,7 @@ declare class Conversations<ContentTypes = unknown> {
      * @param options.consentStates - Optional consent states to filter messages
      * @returns Stream instance for new DM messages
      */
-    streamAllDmMessages(options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+    streamAllDmMessages(options?: StreamOptions<DecodedMessage$1, DecodedMessage<ContentTypes>> & {
         consentStates?: ConsentState[];
     }): Promise<AsyncStreamProxy<DecodedMessage<ContentTypes>>>;
     /**
@@ -1981,14 +1984,13 @@ declare class Conversations<ContentTypes = unknown> {
  *
  * This class is not intended to be initialized directly.
  */
-declare class DebugInformation<ContentTypes = unknown> {
+declare class DebugInformation {
     #private;
-    constructor(client: Client<ContentTypes>);
-    apiStatistics(): Promise<SafeApiStats>;
-    apiIdentityStatistics(): Promise<SafeIdentityStats>;
+    constructor(worker: WorkerBridge<ClientWorkerAction>);
+    apiStatistics(): Promise<_xmtp_wasm_bindings.ApiStats>;
+    apiIdentityStatistics(): Promise<_xmtp_wasm_bindings.IdentityStats>;
     apiAggregateStatistics(): Promise<string>;
     clearAllStatistics(): Promise<void>;
-    uploadDebugArchive(serverUrl?: string): Promise<string>;
 }
 
 /**
@@ -1996,44 +1998,49 @@ declare class DebugInformation<ContentTypes = unknown> {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Preferences<ContentTypes = unknown> {
+declare class Preferences {
     #private;
     /**
      * Creates a new preferences instance
      *
      * @param client - The client instance managing preferences
      */
-    constructor(client: Client<ContentTypes>);
+    constructor(worker: WorkerBridge<ClientWorkerAction>);
     sync(): Promise<_xmtp_wasm_bindings.GroupSyncSummary>;
     /**
-     * Retrieves the current inbox state
+     * Retrieves the current inbox state of this client from the local database
      *
-     * @param refreshFromNetwork - Optional flag to force refresh from network
      * @returns Promise that resolves with the inbox state
      */
-    inboxState(refreshFromNetwork?: boolean): Promise<SafeInboxState>;
+    inboxState(): Promise<_xmtp_wasm_bindings.InboxState>;
     /**
-     * Retrieves inbox state for specific inbox IDs
+     * Retrieves the latest inbox state of this client from the network
+     *
+     * @returns Promise that resolves with the inbox state
+     */
+    fetchInboxState(): Promise<_xmtp_wasm_bindings.InboxState>;
+    /**
+     * Retrieves the current inbox states for specified inbox IDs from the local
+     * database
      *
      * @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
+     * @returns Promise that resolves with the inbox states for the inbox IDs
      */
-    inboxStateFromInboxIds(inboxIds: string[], refreshFromNetwork?: boolean): Promise<SafeInboxState[]>;
+    getInboxStates(inboxIds: string[]): Promise<_xmtp_wasm_bindings.InboxState[]>;
     /**
-     * Gets the latest inbox state for a specific inbox
+     * Retrieves the latest inbox states for specified inbox IDs from the network
      *
-     * @param inboxId - The inbox ID to get state for
-     * @returns Promise that resolves with the latest inbox state
+     * @param inboxIds - Array of inbox IDs to get state for
+     * @returns Promise that resolves with the inbox states for the inbox IDs
      */
-    getLatestInboxState(inboxId: string): Promise<SafeInboxState>;
+    fetchInboxStates(inboxIds: string[]): Promise<_xmtp_wasm_bindings.InboxState[]>;
     /**
      * Updates consent states for multiple records
      *
      * @param records - Array of consent records to update
      * @returns Promise that resolves when consent states are updated
      */
-    setConsentStates(records: SafeConsent[]): Promise<void>;
+    setConsentStates(records: Consent[]): Promise<void>;
     /**
      * Retrieves consent state for a specific entity
      *
@@ -2041,32 +2048,27 @@ declare class Preferences<ContentTypes = unknown> {
      * @param entity - Entity identifier
      * @returns Promise that resolves with the consent state
      */
-    getConsentState(entityType: ConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.ConsentState>;
+    getConsentState(entityType: ConsentEntityType, entity: string): Promise<ConsentState>;
     /**
      * Creates a stream of consent state updates
      *
      * @param options - Optional stream options
      * @returns Stream instance for consent updates
      */
-    streamConsent(options?: StreamOptions<SafeConsent[]>): Promise<AsyncStreamProxy<SafeConsent[]>>;
+    streamConsent(options?: StreamOptions<Consent[]>): Promise<AsyncStreamProxy<Consent[]>>;
     /**
      * Creates a stream of user preference updates
      *
      * @param options - Optional stream options
      * @returns Stream instance for preference updates
      */
-    streamPreferences(options?: StreamOptions<UserPreference[]>): Promise<AsyncStreamProxy<UserPreference[]>>;
+    streamPreferences(options?: StreamOptions<UserPreferenceUpdate[]>): Promise<AsyncStreamProxy<UserPreferenceUpdate[]>>;
 }
 
-type ExtractCodecContentTypes<C extends ContentCodec[] = []> = [
-    ...C,
-    GroupUpdatedCodec,
-    TextCodec
-][number] extends ContentCodec<infer T> ? T : never;
 /**
  * Client for interacting with the XMTP network
  */
-declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWorkerClass {
+declare class Client<ContentTypes = ExtractCodecContentTypes> {
     #private;
     /**
      * Creates a new XMTP client instance
@@ -2086,6 +2088,10 @@ declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWork
      * @param identifier - The identifier to initialize the client with
      */
     init(identifier: Identifier): Promise<void>;
+    /**
+     * Shutdown the client
+     */
+    close(): void;
     /**
      * Creates a new client instance with a signer
      *
@@ -2144,19 +2150,19 @@ declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWork
     /**
      * Gets the debug information helpers for this client
      */
-    get debugInformation(): DebugInformation<ContentTypes>;
+    get debugInformation(): DebugInformation;
     /**
      * Gets the preferences manager for this client
      */
-    get preferences(): Preferences<ContentTypes>;
+    get preferences(): Preferences;
     /**
      * Gets the version of libxmtp used in the bindings
      */
-    libxmtpVersion(): Promise<string>;
+    get libxmtpVersion(): string | undefined;
     /**
      * Gets the app version used by the client
      */
-    appVersion(): Promise<string>;
+    get appVersion(): string | undefined;
     /**
      * Creates signature text for creating a new inbox
      *
@@ -2332,15 +2338,16 @@ declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWork
      * @param inboxId - The inbox ID to revoke installations for
      * @param installationIds - The installation IDs to revoke
      */
-    static revokeInstallations(signer: Signer, inboxId: string, installationIds: Uint8Array[], env?: XmtpEnv, gatewayHost?: string, enableLogging?: boolean): Promise<void>;
+    static revokeInstallations(signer: Signer, inboxId: string, installationIds: Uint8Array[], env?: XmtpEnv, gatewayHost?: string): Promise<void>;
     /**
-     * Gets the inbox state for the specified inbox IDs without a client
+     * Fetches the inbox states for the specified inbox IDs from the network
+     * without a client
      *
      * @param inboxIds - The inbox IDs to get the state for
      * @param env - The environment to use
-     * @returns The inbox state for the specified inbox IDs
+     * @returns The inbox states for the specified inbox IDs
      */
-    static inboxStateFromInboxIds(inboxIds: string[], env?: XmtpEnv, enableLogging?: boolean, gatewayHost?: string): Promise<SafeInboxState[]>;
+    static fetchInboxStates(inboxIds: string[], env?: XmtpEnv, gatewayHost?: string): Promise<_xmtp_wasm_bindings.InboxState[]>;
     /**
      * Changes the recovery identifier for the client's inbox
      *
@@ -2372,52 +2379,13 @@ declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWork
      */
     static canMessage(identifiers: Identifier[], env?: XmtpEnv): Promise<Map<string, boolean>>;
     /**
-     * Finds the inbox ID for a given identifier
+     * Fetches the inbox ID for a given identifier from the local database
+     * If not found, fetches from the network
      *
      * @param identifier - The identifier to look up
      * @returns The inbox ID, if found
      */
-    findInboxIdByIdentifier(identifier: Identifier): Promise<string | undefined>;
-    /**
-     * 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 = unknown>(contentType: ContentTypeId$1): ContentCodec<ContentType> | undefined;
-    /**
-     * 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: ContentTypes, contentType: ContentTypeId$1): SafeEncodedContent;
-    /**
-     * Prepares content for sending by encoding it and generating send options from the codec
-     *
-     * @param content - The message content to prepare for sending
-     * @param contentType - The content type identifier for the appropriate codec
-     * @returns An object containing the encoded content and send options
-     * @throws {CodecNotFoundError} When no codec is registered for the specified content type
-     */
-    prepareForSend(content: ContentTypes, contentType: ContentTypeId$1): {
-        encodedContent: SafeEncodedContent;
-        sendOptions: {
-            shouldPush: boolean;
-        };
-    };
-    /**
-     * 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<ContentType = unknown>(message: SafeMessage, contentType: ContentTypeId$1): ContentType;
+    fetchInboxIdByIdentifier(identifier: Identifier): Promise<string | undefined>;
     /**
      * Signs a message with the installation key
      *
@@ -2443,179 +2411,84 @@ declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWork
      */
     verifySignedWithPublicKey(signatureText: string, signatureBytes: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
     /**
-     * Gets the key package statuses for the specified installation IDs
+     * Fetches the key package statuses from the network for the specified
+     * installation IDs
      *
      * @param installationIds - The installation IDs to check
      * @returns The key package statuses
      */
-    getKeyPackageStatusesForInstallationIds(installationIds: string[]): Promise<Map<string, SafeKeyPackageStatus>>;
+    fetchKeyPackageStatuses(installationIds: string[]): Promise<Map<string, _xmtp_wasm_bindings.KeyPackageStatus>>;
 }
 
-type UtilsWorkerAction = {
-    action: "utils.init";
-    id: string;
-    result: undefined;
-    data: {
-        enableLogging: boolean;
-    };
-} | {
-    action: "utils.generateInboxId";
-    id: string;
-    result: string;
-    data: {
-        identifier: Identifier;
-    };
-} | {
-    action: "utils.getInboxIdForIdentifier";
-    id: string;
-    result: string | undefined;
-    data: {
-        identifier: Identifier;
-        env?: XmtpEnv;
-        gatewayHost?: string;
-    };
-} | {
-    action: "utils.revokeInstallationsSignatureText";
-    id: string;
-    result: {
-        signatureText: string;
-        signatureRequestId: string;
-    };
-    data: {
-        env?: XmtpEnv;
-        identifier: Identifier;
-        inboxId: string;
-        gatewayHost?: string;
-        installationIds: Uint8Array[];
-        signatureRequestId: string;
-    };
-} | {
-    action: "utils.revokeInstallations";
-    id: string;
-    result: undefined;
-    data: {
-        env?: XmtpEnv;
-        signer: SafeSigner;
-        signatureRequestId: string;
-        gatewayHost?: string;
-    };
-} | {
-    action: "utils.inboxStateFromInboxIds";
-    id: string;
-    result: SafeInboxState[];
-    data: {
-        inboxIds: string[];
-        env?: XmtpEnv;
-        gatewayHost?: string;
-    };
-};
+declare class Opfs {
+    #private;
+    constructor(enableLogging?: boolean);
+    init(): Promise<void>;
+    close(): void;
+    static create(enableLogging?: boolean): Promise<Opfs>;
+    listFiles(): Promise<string[]>;
+    fileCount(): Promise<number>;
+    poolCapacity(): Promise<number>;
+    fileExists(path: string): Promise<boolean>;
+    deleteFile(path: string): Promise<boolean>;
+    exportDb(path: string): Promise<Uint8Array<ArrayBufferLike>>;
+    importDb(path: string, data: Uint8Array): Promise<void>;
+    clearAll(): Promise<void>;
+}
 
 /**
- * Class that sets up a worker and provides communications for utility functions
+ * Generates an inbox ID for a given identifier
  *
- * This class is not meant to be used directly, it is extended by the Utils class
- * to provide an interface to the worker.
+ * @param identifier - The identifier to generate an inbox ID for
+ * @param nonce - Optional nonce to use for generating the inbox ID
+ * @returns Promise that resolves with the generated inbox ID
+ */
+declare const generateInboxId: (identifier: Identifier, nonce?: bigint) => Promise<string>;
+/**
+ * Gets the inbox ID for a specific identifier and optional environment
  *
- * @param worker - The worker to use for the utils class
- * @param enableLogging - Whether to enable logging in the worker
- * @returns A new UtilsWorkerClass instance
+ * @param identifier - The identifier to get the inbox ID for
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
+ * @returns Promise that resolves with the inbox ID for the identifier
  */
-declare class UtilsWorkerClass {
-    #private;
-    constructor(worker: Worker, enableLogging: boolean);
-    /**
-     * Initializes the utils worker
-     *
-     * @param enableLogging - Whether to enable logging in the worker
-     * @returns A promise that resolves when the worker is initialized
-     */
-    init(): Promise<void>;
-    /**
-     * Sends an action message to the utils worker
-     *
-     * @param action - The action to send to the worker
-     * @param data - The data to send to the worker
-     * @returns A promise that resolves when the action is completed
-     */
-    sendMessage<A extends ActionName<UtilsWorkerAction>>(action: A, data: ExtractActionData<UtilsWorkerAction, A>): [ExtractActionResult<UtilsWorkerAction, A>] extends [undefined] ? Promise<void> : Promise<ExtractActionResult<UtilsWorkerAction, A>>;
-    /**
-     * Handles a message from the utils worker
-     *
-     * @param event - The event to handle
-     */
-    handleMessage: (event: MessageEvent<ActionWithoutData<UtilsWorkerAction> | ActionErrorData<UtilsWorkerAction>>) => void;
-    /**
-     * Removes all event listeners and terminates the worker
-     */
-    close(): void;
-}
+declare const getInboxIdForIdentifier: (identifier: Identifier, env?: XmtpEnv, gatewayHost?: string) => Promise<string | undefined>;
 
 /**
- * Utility class that provides helper functions for XMTP inbox IDs
+ * Gets the name of a metadata field
+ *
+ * @param field - The metadata field to get the name for
+ * @returns The name of the metadata field
  */
-declare class Utils extends UtilsWorkerClass {
-    /**
-     * Creates a new Utils instance
-     *
-     * @param enableLogging - Optional flag to enable logging
-     */
-    constructor(enableLogging?: boolean);
-    /**
-     * Generates an inbox ID for a given identifier
-     *
-     * @param identifier - The identifier to generate an inbox ID for
-     * @returns Promise that resolves with the generated inbox ID
-     */
-    generateInboxId(identifier: Identifier): Promise<string>;
-    /**
-     * Gets the inbox ID for a specific identifier and optional environment
-     *
-     * @param identifier - The identifier to get the inbox ID for
-     * @param env - Optional XMTP environment configuration (default: "dev")
-     * @param gatewayHost - Optional gateway host override
-     * @returns Promise that resolves with the inbox ID for the identifier
-     */
-    getInboxIdForIdentifier(identifier: Identifier, env?: XmtpEnv, gatewayHost?: string): Promise<string | undefined>;
-    /**
-     * Creates signature text for revoking installations
-     *
-     * 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` method instead.
-     *
-     * @param env - The environment to use
-     * @param identifier - The identifier to revoke installations for
-     * @param inboxId - The inbox ID to revoke installations for
-     * @param installationIds - The installation IDs to revoke
-     * @param gatewayHost - Optional gateway host override
-     * @returns The signature text and signature request ID
-     */
-    revokeInstallationsSignatureText(identifier: Identifier, inboxId: string, installationIds: Uint8Array[], env?: XmtpEnv, gatewayHost?: string): Promise<{
-        signatureText: string;
-        signatureRequestId: string;
-    }>;
-    /**
-     * Revokes installations for a given inbox ID
-     *
-     * @param env - The environment to use
-     * @param signer - The signer to use
-     * @param inboxId - The inbox ID to revoke installations for
-     * @param installationIds - The installation IDs to revoke
-     * @param gatewayHost - Optional gateway host override
-     * @returns Promise that resolves with the result of the revoke installations operation
-     */
-    revokeInstallations(signer: Signer, inboxId: string, installationIds: Uint8Array[], env?: XmtpEnv, gatewayHost?: string): Promise<void>;
-    /**
-     * Gets the inbox state for the specified inbox IDs without a client
-     *
-     * @param inboxIds - The inbox IDs to get the state for
-     * @param env - The environment to use
-     * @returns The inbox state for the specified inbox IDs
-     */
-    inboxStateFromInboxIds(inboxIds: string[], env?: XmtpEnv, gatewayHost?: string): Promise<SafeInboxState[]>;
-}
+declare const metadataFieldName: (field: MetadataField) => Promise<string>;
+
+declare const encodeActions: (actions: _xmtp_wasm_bindings.Actions) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeAttachment: (attachment: _xmtp_wasm_bindings.Attachment) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeIntent: (intent: _xmtp_wasm_bindings.Intent) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeMarkdown: (text: string) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeMultiRemoteAttachment: (multi_remote_attachment: _xmtp_wasm_bindings.MultiRemoteAttachment) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeReaction: (reaction: _xmtp_wasm_bindings.Reaction) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeReadReceipt: (read_receipt: _xmtp_wasm_bindings.ReadReceipt) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeRemoteAttachment: (remote_attachment: _xmtp_wasm_bindings.RemoteAttachment) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeText: (text: string) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeTransactionReference: (transaction_reference: _xmtp_wasm_bindings.TransactionReference) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const encodeWalletSendCalls: (wallet_send_calls: _xmtp_wasm_bindings.WalletSendCalls) => Promise<_xmtp_wasm_bindings.EncodedContent>;
+declare const contentTypeActions: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeAttachment: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeGroupUpdated: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeIntent: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeLeaveRequest: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeMarkdown: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeMultiRemoteAttachment: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeReaction: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeReadReceipt: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeRemoteAttachment: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeReply: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeText: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeTransactionReference: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const contentTypeWalletSendCalls: () => Promise<_xmtp_wasm_bindings.ContentTypeId>;
+declare const encryptAttachment: (attachment: _xmtp_wasm_bindings.Attachment) => Promise<_xmtp_wasm_bindings.EncryptedAttachment>;
+declare const decryptAttachment: (encryptedBytes: Uint8Array<ArrayBufferLike>, remoteAttachment: _xmtp_wasm_bindings.RemoteAttachment) => Promise<_xmtp_wasm_bindings.Attachment>;
 
 declare class ClientNotInitializedError extends Error {
     constructor();
@@ -2623,9 +2496,6 @@ declare class ClientNotInitializedError extends Error {
 declare class SignerUnavailableError extends Error {
     constructor();
 }
-declare class CodecNotFoundError extends Error {
-    constructor(contentType: ContentTypeId$1);
-}
 declare class InboxReassignError extends Error {
     constructor();
 }
@@ -2638,18 +2508,18 @@ declare class GroupNotFoundError extends Error {
 declare class StreamNotFoundError extends Error {
     constructor(streamId: string);
 }
-declare class InvalidGroupMembershipChangeError extends Error {
-    constructor(messageId: string);
-}
-declare class MissingContentTypeError extends Error {
-    constructor();
-}
 declare class StreamFailedError extends Error {
     constructor(retryAttempts: number);
 }
 declare class StreamInvalidRetryAttemptsError extends Error {
     constructor();
 }
+declare class OpfsNotInitializedError extends Error {
+    constructor();
+}
+declare class OpfsInitializationError extends Error {
+    constructor();
+}
 
-export { AccountAlreadyAssociatedError, ApiUrls, Client, ClientNotInitializedError, CodecNotFoundError, Conversation, Conversations, DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_DELAY, DecodedMessage, Dm, Group, GroupNotFoundError, HistorySyncUrls, InboxReassignError, InvalidGroupMembershipChangeError, MissingContentTypeError, SignerUnavailableError, StreamFailedError, StreamInvalidRetryAttemptsError, StreamNotFoundError, Utils, createStream, fromContentTypeId, fromEncodedContent, fromSafeConsent, fromSafeContentTypeId, fromSafeCreateDmOptions, fromSafeCreateGroupOptions, fromSafeEncodedContent, fromSafeGroupMember, fromSafeListConversationsOptions, fromSafeListMessagesOptions, fromSafeMessageDisappearingSettings, fromSafePermissionPolicySet, fromSafeSendMessageOpts, toContentTypeId, toEncodedContent, toSafeApiStats, toSafeConsent, toSafeContentTypeId, toSafeConversation, toSafeConversationDebugInfo, toSafeCreateDmOptions, toSafeCreateGroupOptions, toSafeEncodedContent, toSafeGroupMember, toSafeHmacKey, toSafeIdentityStats, toSafeInboxState, toSafeInstallation, toSafeKeyPackageStatus, toSafeListConversationsOptions, toSafeListMessagesOptions, toSafeMessage, toSafeMessageDisappearingSettings, toSafePermissionPolicySet, toSafeSendMessageOpts, toSafeSigner };
-export type { AsyncStreamProxy, ClientOptions, ContentOptions, EOASigner, ExtractCodecContentTypes, HmacKeys, MessageDeliveryStatus, MessageKind, NetworkOptions, OtherOptions, SCWSigner, SafeApiStats, SafeConsent, SafeContentTypeId, SafeConversation, SafeConversationDebugInfo, SafeCreateDmOptions, SafeCreateGroupOptions, SafeEncodedContent, SafeGroupMember, SafeHmacKey, SafeHmacKeys, SafeIdentityStats, SafeInboxState, SafeInstallation, SafeKeyPackageStatus, SafeListConversationsOptions, SafeListMessagesOptions, SafeMessage, SafeMessageDisappearingSettings, SafePermissionPolicySet, SafeSendMessageOpts, SafeSigner, SafeXMTPCursor, Signer, StorageOptions, StreamCallback, StreamFunction, StreamOptions, StreamValueMutator, XmtpEnv };
+export { AccountAlreadyAssociatedError, ApiUrls, Client, ClientNotInitializedError, Conversation, Conversations, DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_DELAY, DecodedMessage, Dm, Group, GroupNotFoundError, HistorySyncUrls, InboxReassignError, Opfs, OpfsInitializationError, OpfsNotInitializedError, SignerUnavailableError, StreamFailedError, StreamInvalidRetryAttemptsError, StreamNotFoundError, contentTypeActions, contentTypeAttachment, contentTypeGroupUpdated, contentTypeIntent, contentTypeLeaveRequest, contentTypeMarkdown, contentTypeMultiRemoteAttachment, contentTypeReaction, contentTypeReadReceipt, contentTypeRemoteAttachment, contentTypeReply, contentTypeText, contentTypeTransactionReference, contentTypeWalletSendCalls, createStream, decryptAttachment, encodeActions, encodeAttachment, encodeIntent, encodeMarkdown, encodeMultiRemoteAttachment, encodeReaction, encodeReadReceipt, encodeRemoteAttachment, encodeText, encodeTransactionReference, encodeWalletSendCalls, encryptAttachment, generateInboxId, getInboxIdForIdentifier, metadataFieldName, toSafeConversation, toSafeSigner };
+export type { AsyncStreamProxy, BuiltInContentTypes, ClientOptions, ContentOptions, EOASigner, EnrichedReply, ExtractCodecContentTypes, HmacKeys, LastReadTimes, NetworkOptions, OtherOptions, SCWSigner, SafeConversation, SafeSigner, Signer, StorageOptions, StreamCallback, StreamFunction, StreamOptions, StreamValueMutator, XmtpEnv };