@xmtp/browser-sdk 2.0.13 → 2.1.1

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 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, SignatureRequestType, ConsentState, ConsentEntityType, ConversationType, PermissionUpdateType, PermissionPolicy, MetadataField, Conversations as Conversations$1, Message, Conversation as Conversation$1, Client as Client$1, Consent, UserPreference, KeyPackageStatus, EncodedContent, MessageDisappearingSettings, HmacKey, GroupPermissionsOptions, DeliveryStatus, GroupMessageKind, ContentType, SortDirection, PermissionLevel, ContentTypeId, ListMessagesOptions, ListConversationsOptions, PermissionPolicySet, CreateGroupOptions, CreateDMOptions, Installation, InboxState, GroupMember } from '@xmtp/wasm-bindings';
+import { Conversations as Conversations$1, ConsentState, Message, Identifier, Conversation as Conversation$1, ConversationType, Client as Client$1, ConsentEntityType, Consent, UserPreference, SignatureRequestType, KeyPackageStatus, PermissionUpdateType, PermissionPolicy, MetadataField, EncodedContent, MessageDisappearingSettings, HmacKey, ConversationDebugInfo, GroupPermissionsOptions, DeliveryStatus, GroupMessageKind, ContentType, SortDirection, PermissionLevel, ContentTypeId, ListMessagesOptions, ListConversationsOptions, PermissionPolicySet, CreateGroupOptions, CreateDMOptions, Installation, InboxState, GroupMember, ApiStats, IdentityStats } from '@xmtp/wasm-bindings';
 export { Consent, ConsentEntityType, ConsentState, ContentType, ContentTypeId, ConversationListItem, ConversationType, CreateDMOptions, CreateGroupOptions, DeliveryStatus, EncodedContent, GroupMember, GroupMembershipState, GroupMessageKind, GroupMetadata, GroupPermissions, GroupPermissionsOptions, HmacKey, Identifier, IdentifierKind, InboxState, Installation, ListConversationsOptions, ListMessagesOptions, LogOptions, Message, MessageDisappearingSettings, MetadataField, PermissionLevel, PermissionPolicy, PermissionPolicySet, PermissionUpdateType, SignatureRequestType, SortDirection, UserPreference } from '@xmtp/wasm-bindings';
+import { GroupUpdatedCodec } from '@xmtp/content-type-group-updated';
+import { TextCodec } from '@xmtp/content-type-text';
 
 type ResolveValue<T> = {
     value: T | undefined;
@@ -87,6 +89,20 @@ type ContentOptions = {
 type StorageOptions = {
     /**
      * Path to the local DB
+     *
+     * There are 3 value types that can be used to specify the database path:
+     *
+     * - `undefined` (or excluded from the client options)
+     *    The database will be created in the current working directory and is based on
+     *    the XMTP environment and client inbox ID.
+     *    Example: `xmtp-dev-<inbox-id>.db3`
+     *
+     * - `null`
+     *    No database will be created and all data will be lost once the client disconnects.
+     *
+     * - `string`
+     *    The given path will be used to create the database.
+     *    Example: `./my-db.db3`
      */
     dbPath?: string | null;
     /**
@@ -111,26 +127,320 @@ type OtherOptions = {
      * Disable automatic registration when creating a client
      */
     disableAutoRegister?: boolean;
+    /**
+     * Disable device sync
+     */
+    disableDeviceSync?: boolean;
 };
 type ClientOptions = NetworkOptions & ContentOptions & StorageOptions & OtherOptions;
 
-type ClientEvents = 
-/**
- * Stream actions
- */
-{
-    action: "endStream";
-    id: string;
-    result: undefined;
-    data: {
-        streamId: string;
+declare class WorkerConversations {
+    #private;
+    constructor(client: WorkerClient, conversations: Conversations$1);
+    sync(): Promise<void>;
+    syncAll(consentStates?: ConsentState[]): Promise<number>;
+    getConversationById(id: string): WorkerConversation | undefined;
+    getMessageById(id: string): Message | 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;
+    stream(callback?: StreamCallback<Conversation$1>, conversationType?: ConversationType): _xmtp_wasm_bindings.StreamCloser;
+    streamGroups(callback?: StreamCallback<Conversation$1>): _xmtp_wasm_bindings.StreamCloser;
+    streamDms(callback?: StreamCallback<Conversation$1>): _xmtp_wasm_bindings.StreamCloser;
+    streamAllMessages(callback?: StreamCallback<Message>, conversationType?: ConversationType, consentStates?: ConsentState[]): _xmtp_wasm_bindings.StreamCloser;
+}
+
+declare class WorkerPreferences {
+    #private;
+    constructor(client: Client$1, conversations: Conversations$1);
+    sync(): Promise<number>;
+    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>;
+    getConsentState(entityType: ConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.ConsentState>;
+    streamConsent(callback?: StreamCallback<Consent[]>): _xmtp_wasm_bindings.StreamCloser;
+    streamPreferences(callback?: StreamCallback<UserPreference[]>): _xmtp_wasm_bindings.StreamCloser;
+}
+
+declare class WorkerClient {
+    #private;
+    constructor(client: Client$1, options?: ClientOptions);
+    static create(identifier: Identifier, options?: Omit<ClientOptions, "codecs">): Promise<WorkerClient>;
+    get accountIdentifier(): Identifier;
+    get inboxId(): string;
+    get installationId(): string;
+    get installationIdBytes(): Uint8Array<ArrayBufferLike>;
+    get isRegistered(): boolean;
+    get conversations(): WorkerConversations;
+    get preferences(): WorkerPreferences;
+    createInboxSignatureText(): string | undefined;
+    addAccountSignatureText(identifier: Identifier): Promise<string | undefined>;
+    removeAccountSignatureText(identifier: Identifier): Promise<string | undefined>;
+    revokeAllAOtherInstallationsSignatureText(): Promise<string | undefined>;
+    revokeInstallationsSignatureText(installationIds: Uint8Array[]): Promise<string | undefined>;
+    changeRecoveryIdentifierSignatureText(identifier: Identifier): Promise<string | undefined>;
+    addEcdsaSignature(type: SignatureRequestType, bytes: Uint8Array): Promise<void>;
+    addScwSignature(type: SignatureRequestType, bytes: Uint8Array, chainId: bigint, blockNumber?: bigint): Promise<void>;
+    applySignatures(): Promise<void>;
+    canMessage(identifiers: Identifier[]): Promise<Map<string, boolean>>;
+    registerIdentity(): Promise<void>;
+    findInboxIdByIdentifier(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>>;
+    apiStatistics(): _xmtp_wasm_bindings.ApiStats;
+    apiIdentityStatistics(): _xmtp_wasm_bindings.IdentityStats;
+    apiAggregateStatistics(): string;
+    uploadDebugArchive(serverUrl?: string): Promise<string>;
+}
+
+declare class WorkerConversation {
+    #private;
+    constructor(client: WorkerClient, group: Conversation$1);
+    get id(): string;
+    get name(): string;
+    updateName(name: string): Promise<void>;
+    get imageUrl(): string;
+    updateImageUrl(imageUrl: string): Promise<void>;
+    get description(): string;
+    updateDescription(description: string): Promise<void>;
+    get isActive(): boolean;
+    get addedByInboxId(): string;
+    get createdAtNs(): bigint;
+    metadata(): Promise<{
+        creatorInboxId: string;
+        conversationType: string;
+    }>;
+    members(): Promise<SafeGroupMember[]>;
+    get admins(): string[];
+    get superAdmins(): string[];
+    get permissions(): {
+        policyType: _xmtp_wasm_bindings.GroupPermissionsOptions;
+        policySet: _xmtp_wasm_bindings.PermissionPolicySet;
     };
+    updatePermission(permissionType: PermissionUpdateType, policy: PermissionPolicy, metadataField?: MetadataField): Promise<void>;
+    isAdmin(inboxId: string): boolean;
+    isSuperAdmin(inboxId: string): boolean;
+    sync(): Promise<void>;
+    addMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
+    addMembers(inboxIds: string[]): Promise<void>;
+    removeMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
+    removeMembers(inboxIds: string[]): Promise<void>;
+    addAdmin(inboxId: string): Promise<void>;
+    removeAdmin(inboxId: string): Promise<void>;
+    addSuperAdmin(inboxId: string): Promise<void>;
+    removeSuperAdmin(inboxId: string): Promise<void>;
+    publishMessages(): Promise<void>;
+    sendOptimistic(encodedContent: EncodedContent): string;
+    send(encodedContent: EncodedContent): Promise<string>;
+    messages(options?: SafeListMessagesOptions): Promise<Message[]>;
+    get consentState(): ConsentState;
+    updateConsentState(state: ConsentState): void;
+    dmPeerInboxId(): string;
+    messageDisappearingSettings(): MessageDisappearingSettings | undefined;
+    updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint): Promise<void>;
+    removeMessageDisappearingSettings(): Promise<void>;
+    isMessageDisappearingEnabled(): boolean;
+    stream(callback?: StreamCallback<Message>): _xmtp_wasm_bindings.StreamCloser;
+    pausedForVersion(): string | undefined;
+    getHmacKeys(): Map<string, HmacKey[]>;
+    debugInfo(): Promise<ConversationDebugInfo>;
+    getDuplicateDms(): Promise<WorkerConversation[]>;
 }
-/**
- * Client actions
- */
- | {
-    action: "init";
+
+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;
+    limit?: bigint;
+    sentAfterNs?: bigint;
+    sentBeforeNs?: bigint;
+};
+declare const toSafeListMessagesOptions: (options: ListMessagesOptions) => SafeListMessagesOptions;
+declare const fromSafeListMessagesOptions: (options: SafeListMessagesOptions) => ListMessagesOptions;
+type SafeListConversationsOptions = {
+    consentStates?: ConsentState[];
+    conversationType?: ConversationType;
+    createdAfterNs?: bigint;
+    createdBeforeNs?: bigint;
+    includeDuplicateDms?: boolean;
+    limit?: bigint;
+};
+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;
+    imageUrl: string;
+    description: string;
+    permissions: {
+        policyType: GroupPermissionsOptions;
+        policySet: {
+            addAdminPolicy: PermissionPolicy;
+            addMemberPolicy: PermissionPolicy;
+            removeAdminPolicy: PermissionPolicy;
+            removeMemberPolicy: PermissionPolicy;
+            updateGroupDescriptionPolicy: PermissionPolicy;
+            updateGroupImageUrlSquarePolicy: PermissionPolicy;
+            updateGroupNamePolicy: PermissionPolicy;
+            updateMessageDisappearingPolicy: PermissionPolicy;
+        };
+    };
+    isActive: boolean;
+    addedByInboxId: string;
+    metadata: {
+        creatorInboxId: string;
+        conversationType: string;
+    };
+    admins: string[];
+    superAdmins: string[];
+    createdAtNs: bigint;
+};
+declare const toSafeConversation: (conversation: WorkerConversation) => Promise<SafeConversation>;
+type SafeInstallation = {
+    bytes: Uint8Array;
+    clientTimestampNs?: bigint;
+    id: string;
+};
+declare const toSafeInstallation: (installation: Installation) => SafeInstallation;
+type SafeInboxState = {
+    accountIdentifiers: 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 SafeConversationDebugInfo = {
+    epoch: bigint;
+    maybeForked: boolean;
+    forkDetails: string;
+};
+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 ClientAction = {
+    action: "client.init";
     id: string;
     result: {
         inboxId: string;
@@ -142,45 +452,45 @@ type ClientEvents =
         options?: ClientOptions;
     };
 } | {
-    action: "createInboxSignatureText";
+    action: "client.createInboxSignatureText";
     id: string;
     result: string | undefined;
     data: undefined;
 } | {
-    action: "addAccountSignatureText";
+    action: "client.addAccountSignatureText";
     id: string;
     result: string | undefined;
     data: {
         newIdentifier: Identifier;
     };
 } | {
-    action: "removeAccountSignatureText";
+    action: "client.removeAccountSignatureText";
     id: string;
     result: string | undefined;
     data: {
         identifier: Identifier;
     };
 } | {
-    action: "revokeAllOtherInstallationsSignatureText";
+    action: "client.revokeAllOtherInstallationsSignatureText";
     id: string;
     result: string | undefined;
     data: undefined;
 } | {
-    action: "revokeInstallationsSignatureText";
+    action: "client.revokeInstallationsSignatureText";
     id: string;
     result: string | undefined;
     data: {
         installationIds: Uint8Array[];
     };
 } | {
-    action: "changeRecoveryIdentifierSignatureText";
+    action: "client.changeRecoveryIdentifierSignatureText";
     id: string;
     result: string | undefined;
     data: {
         identifier: Identifier;
     };
 } | {
-    action: "addEcdsaSignature";
+    action: "client.addEcdsaSignature";
     id: string;
     result: undefined;
     data: {
@@ -188,7 +498,7 @@ type ClientEvents =
         bytes: Uint8Array;
     };
 } | {
-    action: "addScwSignature";
+    action: "client.addScwSignature";
     id: string;
     result: undefined;
     data: {
@@ -198,80 +508,43 @@ type ClientEvents =
         blockNumber?: bigint;
     };
 } | {
-    action: "applySignatures";
+    action: "client.applySignatures";
     id: string;
     result: undefined;
     data: undefined;
 } | {
-    action: "registerIdentity";
+    action: "client.registerIdentity";
     id: string;
     result: undefined;
     data: undefined;
 } | {
-    action: "isRegistered";
+    action: "client.isRegistered";
     id: string;
     result: boolean;
     data: undefined;
 } | {
-    action: "canMessage";
+    action: "client.canMessage";
     id: string;
     result: Map<string, boolean>;
     data: {
         identifiers: Identifier[];
     };
 } | {
-    action: "inboxState";
-    id: string;
-    result: SafeInboxState;
-    data: {
-        refreshFromNetwork: boolean;
-    };
-} | {
-    action: "inboxStateFromInboxIds";
-    id: string;
-    result: SafeInboxState[];
-    data: {
-        inboxIds: string[];
-        refreshFromNetwork: boolean;
-    };
-} | {
-    action: "getLatestInboxState";
-    id: string;
-    result: SafeInboxState;
-    data: {
-        inboxId: string;
-    };
-} | {
-    action: "setConsentStates";
-    id: string;
-    result: undefined;
-    data: {
-        records: SafeConsent[];
-    };
-} | {
-    action: "getConsentState";
-    id: string;
-    result: ConsentState;
-    data: {
-        entityType: ConsentEntityType;
-        entity: string;
-    };
-} | {
-    action: "findInboxIdByIdentifier";
+    action: "client.findInboxIdByIdentifier";
     id: string;
     result: string | undefined;
     data: {
         identifier: Identifier;
     };
 } | {
-    action: "signWithInstallationKey";
+    action: "client.signWithInstallationKey";
     id: string;
     result: Uint8Array;
     data: {
         signatureText: string;
     };
 } | {
-    action: "verifySignedWithInstallationKey";
+    action: "client.verifySignedWithInstallationKey";
     id: string;
     result: boolean;
     data: {
@@ -279,7 +552,7 @@ type ClientEvents =
         signatureBytes: Uint8Array;
     };
 } | {
-    action: "verifySignedWithPublicKey";
+    action: "client.verifySignedWithPublicKey";
     id: string;
     result: boolean;
     data: {
@@ -288,786 +561,570 @@ type ClientEvents =
         publicKey: Uint8Array;
     };
 } | {
-    action: "getKeyPackageStatusesForInstallationIds";
+    action: "client.getKeyPackageStatusesForInstallationIds";
     id: string;
     result: Map<string, SafeKeyPackageStatus>;
     data: {
         installationIds: string[];
     };
-}
-/**
- * Conversations actions
- */
- | {
-    action: "getConversationById";
+} | {
+    action: "client.apiStatistics";
     id: string;
-    result: SafeConversation | undefined;
-    data: {
-        id: string;
-    };
+    result: SafeApiStats;
+    data: undefined;
 } | {
-    action: "getMessageById";
+    action: "client.apiIdentityStatistics";
     id: string;
-    result: SafeMessage | undefined;
-    data: {
-        id: string;
-    };
+    result: SafeIdentityStats;
+    data: undefined;
 } | {
-    action: "getDmByInboxId";
+    action: "client.apiAggregateStatistics";
     id: string;
-    result: SafeConversation | undefined;
-    data: {
-        inboxId: string;
-    };
+    result: string;
+    data: undefined;
 } | {
-    action: "getConversations";
+    action: "client.uploadDebugArchive";
     id: string;
-    result: SafeConversation[];
+    result: string;
     data: {
-        options?: SafeListConversationsOptions;
+        serverUrl?: string;
     };
-} | {
-    action: "getGroups";
+};
+
+type ConversationAction = {
+    action: "conversation.sync";
     id: string;
-    result: SafeConversation[];
+    result: SafeConversation;
     data: {
-        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+        id: string;
     };
 } | {
-    action: "getDms";
+    action: "conversation.send";
     id: string;
-    result: SafeConversation[];
+    result: string;
     data: {
-        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+        id: string;
+        content: SafeEncodedContent;
     };
 } | {
-    action: "newGroupWithIdentifiers";
+    action: "conversation.sendOptimistic";
     id: string;
-    result: SafeConversation;
+    result: string;
     data: {
-        identifiers: Identifier[];
-        options?: SafeCreateGroupOptions;
+        id: string;
+        content: SafeEncodedContent;
     };
 } | {
-    action: "newGroupWithInboxIds";
+    action: "conversation.publishMessages";
     id: string;
-    result: SafeConversation;
+    result: undefined;
     data: {
-        inboxIds: string[];
-        options?: SafeCreateGroupOptions;
+        id: string;
     };
 } | {
-    action: "newDmWithIdentifier";
+    action: "conversation.messages";
     id: string;
-    result: SafeConversation;
+    result: SafeMessage[];
     data: {
-        identifier: Identifier;
-        options?: SafeCreateDmOptions;
+        id: string;
+        options?: SafeListMessagesOptions;
     };
 } | {
-    action: "newDmWithInboxId";
+    action: "conversation.members";
     id: string;
-    result: SafeConversation;
+    result: SafeGroupMember[];
     data: {
-        inboxId: string;
-        options?: SafeCreateDmOptions;
+        id: string;
     };
 } | {
-    action: "syncConversations";
-    id: string;
-    result: undefined;
-    data: undefined;
-} | {
-    action: "syncAllConversations";
+    action: "conversation.messageDisappearingSettings";
     id: string;
-    result: undefined;
+    result: SafeMessageDisappearingSettings | undefined;
     data: {
-        consentStates?: ConsentState[];
+        id: string;
     };
 } | {
-    action: "getHmacKeys";
-    id: string;
-    result: SafeHmacKeys;
-    data: undefined;
-} | {
-    action: "streamAllGroups";
+    action: "conversation.updateMessageDisappearingSettings";
     id: string;
     result: undefined;
-    data: {
-        streamId: string;
-        conversationType?: ConversationType;
+    data: SafeMessageDisappearingSettings & {
+        id: string;
     };
 } | {
-    action: "streamAllMessages";
+    action: "conversation.removeMessageDisappearingSettings";
     id: string;
     result: undefined;
     data: {
-        streamId: string;
-        conversationType?: ConversationType;
+        id: string;
     };
 } | {
-    action: "streamConsent";
+    action: "conversation.isMessageDisappearingEnabled";
     id: string;
-    result: undefined;
+    result: boolean;
     data: {
-        streamId: string;
+        id: string;
     };
 } | {
-    action: "streamPreferences";
+    action: "conversation.stream";
     id: string;
     result: undefined;
     data: {
+        groupId: string;
         streamId: string;
     };
-}
-/**
- * Group actions
- */
- | {
-    action: "syncGroup";
-    id: string;
-    result: SafeConversation;
-    data: {
-        id: string;
-    };
 } | {
-    action: "sendGroupMessage";
+    action: "conversation.pausedForVersion";
     id: string;
-    result: string;
+    result: string | undefined;
     data: {
         id: string;
-        content: SafeEncodedContent;
     };
 } | {
-    action: "sendOptimisticGroupMessage";
+    action: "conversation.getHmacKeys";
     id: string;
-    result: string;
+    result: Map<string, SafeHmacKey[]>;
     data: {
         id: string;
-        content: SafeEncodedContent;
     };
 } | {
-    action: "publishGroupMessages";
+    action: "conversation.debugInfo";
     id: string;
-    result: undefined;
+    result: SafeConversationDebugInfo;
     data: {
         id: string;
     };
 } | {
-    action: "getGroupMessages";
+    action: "conversation.consentState";
     id: string;
-    result: SafeMessage[];
+    result: ConsentState;
     data: {
         id: string;
-        options?: SafeListMessagesOptions;
     };
 } | {
-    action: "getGroupMembers";
+    action: "conversation.updateConsentState";
     id: string;
-    result: SafeGroupMember[];
+    result: undefined;
     data: {
         id: string;
+        state: ConsentState;
     };
-} | {
-    action: "getGroupAdmins";
+};
+
+type ConversationsAction = {
+    action: "conversations.getConversationById";
     id: string;
-    result: string[];
+    result: SafeConversation | undefined;
     data: {
         id: string;
     };
 } | {
-    action: "getGroupSuperAdmins";
+    action: "conversations.getMessageById";
     id: string;
-    result: string[];
+    result: SafeMessage | undefined;
     data: {
         id: string;
     };
 } | {
-    action: "isGroupAdmin";
+    action: "conversations.getDmByInboxId";
     id: string;
-    result: boolean;
+    result: SafeConversation | undefined;
     data: {
-        id: string;
         inboxId: string;
     };
 } | {
-    action: "isGroupSuperAdmin";
+    action: "conversations.list";
     id: string;
-    result: boolean;
+    result: SafeConversation[];
     data: {
-        id: string;
-        inboxId: string;
+        options?: SafeListConversationsOptions;
     };
 } | {
-    action: "addGroupMembers";
+    action: "conversations.listGroups";
     id: string;
-    result: undefined;
+    result: SafeConversation[];
     data: {
-        id: string;
-        identifiers: Identifier[];
+        options?: Omit<SafeListConversationsOptions, "conversation_type">;
     };
 } | {
-    action: "removeGroupMembers";
+    action: "conversations.listDms";
     id: string;
-    result: undefined;
+    result: SafeConversation[];
     data: {
-        id: string;
-        identifiers: Identifier[];
+        options?: Omit<SafeListConversationsOptions, "conversation_type">;
     };
 } | {
-    action: "addGroupMembersByInboxId";
+    action: "conversations.newGroupOptimistic";
     id: string;
-    result: undefined;
+    result: SafeConversation;
     data: {
-        id: string;
-        inboxIds: string[];
+        options?: SafeCreateGroupOptions;
     };
 } | {
-    action: "removeGroupMembersByInboxId";
+    action: "conversations.newGroupWithIdentifiers";
     id: string;
-    result: undefined;
+    result: SafeConversation;
     data: {
-        id: string;
-        inboxIds: string[];
+        identifiers: Identifier[];
+        options?: SafeCreateGroupOptions;
     };
 } | {
-    action: "addGroupAdmin";
+    action: "conversations.newGroup";
     id: string;
-    result: undefined;
+    result: SafeConversation;
     data: {
-        id: string;
-        inboxId: string;
+        inboxIds: string[];
+        options?: SafeCreateGroupOptions;
     };
 } | {
-    action: "removeGroupAdmin";
+    action: "conversations.newDmWithIdentifier";
     id: string;
-    result: undefined;
+    result: SafeConversation;
     data: {
-        id: string;
-        inboxId: string;
+        identifier: Identifier;
+        options?: SafeCreateDmOptions;
     };
 } | {
-    action: "addGroupSuperAdmin";
+    action: "conversations.newDm";
     id: string;
-    result: undefined;
+    result: SafeConversation;
     data: {
-        id: string;
         inboxId: string;
+        options?: SafeCreateDmOptions;
     };
 } | {
-    action: "removeGroupSuperAdmin";
+    action: "conversations.sync";
     id: string;
     result: undefined;
-    data: {
-        id: string;
-        inboxId: string;
-    };
+    data: undefined;
 } | {
-    action: "updateGroupName";
+    action: "conversations.syncAll";
     id: string;
     result: undefined;
     data: {
-        id: string;
-        name: string;
+        consentStates?: ConsentState[];
     };
 } | {
-    action: "updateGroupDescription";
+    action: "conversations.getHmacKeys";
     id: string;
-    result: undefined;
-    data: {
-        id: string;
-        description: string;
-    };
+    result: SafeHmacKeys;
+    data: undefined;
 } | {
-    action: "updateGroupImageUrlSquare";
+    action: "conversations.stream";
     id: string;
     result: undefined;
     data: {
-        id: string;
-        imageUrl: string;
-    };
-} | {
-    action: "getGroupConsentState";
-    id: string;
-    result: ConsentState;
-    data: {
-        id: string;
+        streamId: string;
+        conversationType?: ConversationType;
     };
 } | {
-    action: "updateGroupConsentState";
+    action: "conversations.streamAllMessages";
     id: string;
     result: undefined;
     data: {
-        id: string;
-        state: ConsentState;
-    };
-} | {
-    action: "getDmPeerInboxId";
-    id: string;
-    result: string;
-    data: {
-        id: string;
+        streamId: string;
+        conversationType?: ConversationType;
+        consentStates?: ConsentState[];
     };
-} | {
-    action: "updateGroupPermissionPolicy";
+};
+
+type DmAction = {
+    action: "dm.peerInboxId";
     id: string;
-    result: undefined;
+    result: string;
     data: {
         id: string;
-        permissionType: PermissionUpdateType;
-        policy: PermissionPolicy;
-        metadataField?: MetadataField;
     };
 } | {
-    action: "getGroupPermissions";
+    action: "dm.getDuplicateDms";
     id: string;
-    result: SafeConversation["permissions"];
+    result: SafeConversation[];
     data: {
         id: string;
     };
-} | {
-    action: "getGroupMessageDisappearingSettings";
+};
+
+type GroupAction = {
+    action: "group.listAdmins";
     id: string;
-    result: SafeMessageDisappearingSettings | undefined;
+    result: string[];
     data: {
         id: string;
     };
 } | {
-    action: "updateGroupMessageDisappearingSettings";
+    action: "group.listSuperAdmins";
     id: string;
-    result: undefined;
-    data: SafeMessageDisappearingSettings & {
+    result: string[];
+    data: {
         id: string;
     };
 } | {
-    action: "removeGroupMessageDisappearingSettings";
+    action: "group.isAdmin";
     id: string;
-    result: undefined;
+    result: boolean;
     data: {
         id: string;
+        inboxId: string;
     };
 } | {
-    action: "isGroupMessageDisappearingEnabled";
+    action: "group.isSuperAdmin";
     id: string;
     result: boolean;
     data: {
         id: string;
+        inboxId: string;
     };
 } | {
-    action: "streamGroupMessages";
+    action: "group.addMembersByIdentifiers";
     id: string;
     result: undefined;
     data: {
-        groupId: string;
-        streamId: string;
+        id: string;
+        identifiers: Identifier[];
     };
 } | {
-    action: "getGroupPausedForVersion";
+    action: "group.removeMembersByIdentifiers";
     id: string;
-    result: string | undefined;
+    result: undefined;
     data: {
         id: string;
+        identifiers: Identifier[];
     };
 } | {
-    action: "getGroupHmacKeys";
+    action: "group.addMembers";
     id: string;
-    result: SafeHmacKey[];
+    result: undefined;
     data: {
         id: string;
+        inboxIds: string[];
     };
-};
-type ClientEventsActions = ClientEvents["action"];
-type ClientEventsClientMessageData = EventsClientMessageData<ClientEvents>;
-type ClientEventsWorkerMessageData = EventsWorkerMessageData<ClientEvents>;
-type ClientEventsResult<A extends ClientEventsActions> = EventsResult<ClientEvents, A>;
-type ClientSendMessageData<A extends ClientEventsActions> = SendMessageData<ClientEvents, A>;
-type ClientEventsWorkerPostMessageData<A extends ClientEventsActions> = EventsWorkerPostMessageData<ClientEvents, A>;
-type ClientEventsClientPostMessageData<A extends ClientEventsActions> = EventsClientPostMessageData<ClientEvents, A>;
-type ClientEventsErrorData = EventsErrorData<ClientEvents>;
-
-type UtilsEvents = {
-    action: "init";
+} | {
+    action: "group.removeMembers";
     id: string;
     result: undefined;
     data: {
-        enableLogging: boolean;
+        id: string;
+        inboxIds: string[];
     };
 } | {
-    action: "generateInboxId";
+    action: "group.addAdmin";
     id: string;
-    result: string;
+    result: undefined;
     data: {
-        identifier: Identifier;
+        id: string;
+        inboxId: string;
     };
 } | {
-    action: "getInboxIdForIdentifier";
+    action: "group.removeAdmin";
     id: string;
-    result: string | undefined;
+    result: undefined;
     data: {
-        identifier: Identifier;
-        env?: XmtpEnv;
+        id: string;
+        inboxId: string;
     };
-};
-type UtilsEventsActions = UtilsEvents["action"];
-type UtilsEventsClientMessageData = EventsClientMessageData<UtilsEvents>;
-type UtilsEventsWorkerMessageData = EventsWorkerMessageData<UtilsEvents>;
-type UtilsEventsResult<A extends UtilsEventsActions> = EventsResult<UtilsEvents, A>;
-type UtilsSendMessageData<A extends UtilsEventsActions> = SendMessageData<UtilsEvents, A>;
-type UtilsEventsWorkerPostMessageData<A extends UtilsEventsActions> = EventsWorkerPostMessageData<UtilsEvents, A>;
-type UtilsEventsClientPostMessageData<A extends UtilsEventsActions> = EventsClientPostMessageData<UtilsEvents, A>;
-type UtilsEventsErrorData = EventsErrorData<UtilsEvents>;
-
-type GenericEvent = {
-    action: string;
+} | {
+    action: "group.addSuperAdmin";
     id: string;
-    result: unknown;
-    data: unknown;
-};
-type EventsClientMessageData<Events extends GenericEvent> = {
-    [Action in Events["action"]]: Omit<Extract<Events, {
-        action: Action;
-    }>, "result">;
-}[Events["action"]];
-type EventsWorkerMessageData<Events extends GenericEvent> = {
-    [Action in Events["action"]]: Omit<Extract<Events, {
-        action: Action;
-    }>, "data">;
-}[Events["action"]];
-type EventsResult<Events extends GenericEvent, Action extends Events["action"]> = Extract<Events, {
-    action: Action;
-}>["result"];
-type SendMessageData<Events extends GenericEvent, Action extends Events["action"]> = Extract<Events, {
-    action: Action;
-}>["data"];
-type EventsWorkerPostMessageData<Events extends GenericEvent, Action extends Events["action"]> = Omit<Extract<Events, {
-    action: Action;
-}>, "data">;
-type EventsClientPostMessageData<Events extends GenericEvent, Action extends Events["action"]> = Omit<Extract<Events, {
-    action: Action;
-}>, "result">;
-type EventsErrorData<Events extends GenericEvent> = {
-    id: string;
-    action: Events["action"];
-    error: Error;
-};
-type GenericStreamEvent = {
-    type: string;
-    streamId: string;
-    result: unknown;
-};
-type StreamEventsClientMessageData<Events extends GenericStreamEvent> = {
-    [Type in Events["type"]]: Omit<Extract<Events, {
-        type: Type;
-    }>, "result">;
-}[Events["type"]];
-type StreamEventsResult<Events extends GenericStreamEvent, Type extends Events["type"]> = Extract<Events, {
-    type: Type;
-}>["result"];
-type StreamEventsClientPostMessageData<Events extends GenericStreamEvent, Type extends Events["type"]> = Extract<Events, {
-    type: Type;
-}>;
-type StreamEventsErrorData<Events extends GenericStreamEvent> = {
-    streamId: string;
-    type: Events["type"];
-    error: Error;
-};
-
-declare class WorkerConversations {
-    #private;
-    constructor(client: WorkerClient, conversations: Conversations$1);
-    sync(): Promise<void>;
-    syncAll(consentStates?: ConsentState[]): Promise<number>;
-    getConversationById(id: string): WorkerConversation | undefined;
-    getMessageById(id: string): Message | undefined;
-    getDmByInboxId(inboxId: string): WorkerConversation | undefined;
-    list(options?: SafeListConversationsOptions): WorkerConversation[];
-    listGroups(options?: Omit<SafeListConversationsOptions, "conversation_type">): WorkerConversation[];
-    listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">): 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;
-    stream(callback?: StreamCallback<Conversation$1>, conversationType?: ConversationType): _xmtp_wasm_bindings.StreamCloser;
-    streamGroups(callback?: StreamCallback<Conversation$1>): _xmtp_wasm_bindings.StreamCloser;
-    streamDms(callback?: StreamCallback<Conversation$1>): _xmtp_wasm_bindings.StreamCloser;
-    streamAllMessages(callback?: StreamCallback<Message>, conversationType?: ConversationType): _xmtp_wasm_bindings.StreamCloser;
-}
-
-declare class WorkerPreferences {
-    #private;
-    constructor(client: Client$1, conversations: Conversations$1);
-    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>;
-    getConsentState(entityType: ConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.ConsentState>;
-    streamConsent(callback?: StreamCallback<Consent[]>): _xmtp_wasm_bindings.StreamCloser;
-    streamPreferences(callback?: StreamCallback<UserPreference[]>): _xmtp_wasm_bindings.StreamCloser;
-}
-
-declare class WorkerClient {
-    #private;
-    constructor(client: Client$1);
-    static create(identifier: Identifier, options?: Omit<ClientOptions, "codecs">): Promise<WorkerClient>;
-    get accountIdentifier(): Identifier;
-    get inboxId(): string;
-    get installationId(): string;
-    get installationIdBytes(): Uint8Array<ArrayBufferLike>;
-    get isRegistered(): boolean;
-    get conversations(): WorkerConversations;
-    get preferences(): WorkerPreferences;
-    createInboxSignatureText(): string | undefined;
-    addAccountSignatureText(identifier: Identifier): Promise<string | undefined>;
-    removeAccountSignatureText(identifier: Identifier): Promise<string | undefined>;
-    revokeAllAOtherInstallationsSignatureText(): Promise<string | undefined>;
-    revokeInstallationsSignatureText(installationIds: Uint8Array[]): Promise<string | undefined>;
-    changeRecoveryIdentifierSignatureText(identifier: Identifier): Promise<string | undefined>;
-    addEcdsaSignature(type: SignatureRequestType, bytes: Uint8Array): Promise<void>;
-    addScwSignature(type: SignatureRequestType, bytes: Uint8Array, chainId: bigint, blockNumber?: bigint): Promise<void>;
-    applySignatures(): Promise<void>;
-    canMessage(identifiers: Identifier[]): Promise<Map<string, boolean>>;
-    registerIdentity(): Promise<void>;
-    findInboxIdByIdentifier(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>>;
-}
-
-declare class WorkerConversation {
-    #private;
-    constructor(client: WorkerClient, group: Conversation$1);
-    get id(): string;
-    get name(): string;
-    updateName(name: string): Promise<void>;
-    get imageUrl(): string;
-    updateImageUrl(imageUrl: string): Promise<void>;
-    get description(): string;
-    updateDescription(description: string): Promise<void>;
-    get isActive(): boolean;
-    get addedByInboxId(): string;
-    get createdAtNs(): bigint;
-    metadata(): Promise<{
-        creatorInboxId: string;
-        conversationType: string;
-    }>;
-    members(): Promise<SafeGroupMember[]>;
-    get admins(): string[];
-    get superAdmins(): string[];
-    get permissions(): {
-        policyType: _xmtp_wasm_bindings.GroupPermissionsOptions;
-        policySet: _xmtp_wasm_bindings.PermissionPolicySet;
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
     };
-    updatePermission(permissionType: PermissionUpdateType, policy: PermissionPolicy, metadataField?: MetadataField): Promise<void>;
-    isAdmin(inboxId: string): boolean;
-    isSuperAdmin(inboxId: string): boolean;
-    sync(): Promise<void>;
-    addMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
-    addMembers(inboxIds: string[]): Promise<void>;
-    removeMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
-    removeMembers(inboxIds: string[]): Promise<void>;
-    addAdmin(inboxId: string): Promise<void>;
-    removeAdmin(inboxId: string): Promise<void>;
-    addSuperAdmin(inboxId: string): Promise<void>;
-    removeSuperAdmin(inboxId: string): Promise<void>;
-    publishMessages(): Promise<void>;
-    sendOptimistic(encodedContent: EncodedContent): string;
-    send(encodedContent: EncodedContent): Promise<string>;
-    messages(options?: SafeListMessagesOptions): Promise<Message[]>;
-    get consentState(): ConsentState;
-    updateConsentState(state: ConsentState): void;
-    dmPeerInboxId(): string;
-    messageDisappearingSettings(): MessageDisappearingSettings | undefined;
-    updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint): Promise<void>;
-    removeMessageDisappearingSettings(): Promise<void>;
-    isMessageDisappearingEnabled(): boolean;
-    stream(callback?: StreamCallback<Message>): _xmtp_wasm_bindings.StreamCloser;
-    pausedForVersion(): string | undefined;
-    getHmacKeys(): HmacKey[];
-}
-
-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;
-    limit?: bigint;
-    sentAfterNs?: bigint;
-    sentBeforeNs?: bigint;
-};
-declare const toSafeListMessagesOptions: (options: ListMessagesOptions) => SafeListMessagesOptions;
-declare const fromSafeListMessagesOptions: (options: SafeListMessagesOptions) => ListMessagesOptions;
-type SafeListConversationsOptions = {
-    consentStates?: ConsentState[];
-    createdAfterNs?: bigint;
-    createdBeforeNs?: bigint;
-    includeDuplicateDms?: boolean;
-    limit?: bigint;
-};
-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 = {
+} | {
+    action: "group.removeSuperAdmin";
     id: string;
-    name: string;
-    imageUrl: string;
-    description: string;
-    permissions: {
-        policyType: GroupPermissionsOptions;
-        policySet: {
-            addAdminPolicy: PermissionPolicy;
-            addMemberPolicy: PermissionPolicy;
-            removeAdminPolicy: PermissionPolicy;
-            removeMemberPolicy: PermissionPolicy;
-            updateGroupDescriptionPolicy: PermissionPolicy;
-            updateGroupImageUrlSquarePolicy: PermissionPolicy;
-            updateGroupNamePolicy: PermissionPolicy;
-            updateMessageDisappearingPolicy: PermissionPolicy;
-        };
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
     };
-    isActive: boolean;
-    addedByInboxId: string;
-    metadata: {
-        creatorInboxId: string;
-        conversationType: string;
+} | {
+    action: "group.updateName";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        name: string;
     };
-    admins: string[];
-    superAdmins: string[];
-    createdAtNs: bigint;
-};
-declare const toSafeConversation: (conversation: WorkerConversation) => Promise<SafeConversation>;
-type SafeInstallation = {
-    bytes: Uint8Array;
-    clientTimestampNs?: bigint;
+} | {
+    action: "group.updateDescription";
     id: string;
+    result: undefined;
+    data: {
+        id: string;
+        description: string;
+    };
+} | {
+    action: "group.updateImageUrl";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        imageUrl: string;
+    };
+} | {
+    action: "group.updatePermission";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        permissionType: PermissionUpdateType;
+        policy: PermissionPolicy;
+        metadataField?: MetadataField;
+    };
+} | {
+    action: "group.permissions";
+    id: string;
+    result: SafeConversation["permissions"];
+    data: {
+        id: string;
+    };
 };
-declare const toSafeInstallation: (installation: Installation) => SafeInstallation;
-type SafeInboxState = {
-    accountIdentifiers: 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;
+
+type PreferencesAction = {
+    action: "preferences.inboxState";
+    id: string;
+    result: SafeInboxState;
+    data: {
+        refreshFromNetwork: boolean;
+    };
+} | {
+    action: "preferences.inboxStateFromInboxIds";
+    id: string;
+    result: SafeInboxState[];
+    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[];
+    };
+} | {
+    action: "preferences.getConsentState";
+    id: string;
+    result: ConsentState;
+    data: {
+        entityType: ConsentEntityType;
+        entity: string;
+    };
+} | {
+    action: "preferences.sync";
+    id: string;
+    result: number;
+    data: undefined;
+} | {
+    action: "preferences.streamConsent";
+    id: string;
+    result: undefined;
+    data: {
+        streamId: string;
+    };
+} | {
+    action: "preferences.streamPreferences";
+    id: string;
+    result: undefined;
+    data: {
+        streamId: string;
+    };
 };
-declare const toSafeHmacKey: (hmacKey: HmacKey) => SafeHmacKey;
-type HmacKeys = Map<string, HmacKey[]>;
-type SafeHmacKeys = Record<string, SafeHmacKey[]>;
-type SafeMessageDisappearingSettings = {
-    fromNs: bigint;
-    inNs: bigint;
+
+type UnknownAction = {
+    action: string;
+    id: string;
+    result: unknown;
+    data: unknown;
 };
-declare const toSafeMessageDisappearingSettings: (settings: MessageDisappearingSettings) => SafeMessageDisappearingSettings;
-declare const fromSafeMessageDisappearingSettings: (settings: SafeMessageDisappearingSettings) => MessageDisappearingSettings;
-type SafeKeyPackageStatus = {
-    lifetime?: {
-        notBefore: bigint;
-        notAfter: bigint;
+type ClientWorkerAction = {
+    action: "endStream";
+    id: string;
+    result: undefined;
+    data: {
+        streamId: string;
     };
-    validationError?: string;
+} | ClientAction | ConversationAction | ConversationsAction | DmAction | GroupAction | PreferencesAction;
+type ActionName<T extends UnknownAction> = T["action"];
+type ExtractAction<T extends UnknownAction, A extends ActionName<T>> = Extract<T, {
+    action: A;
+}>;
+type ExtractActionData<T extends UnknownAction, A extends ActionName<T>> = ExtractAction<T, A>["data"];
+type ExtractActionResult<T extends UnknownAction, A extends ActionName<T>> = ExtractAction<T, A>["result"];
+type ActionWithoutData<T extends UnknownAction> = {
+    [A in T["action"]]: Omit<Extract<T, {
+        action: A;
+    }>, "data">;
+}[T["action"]];
+type ActionErrorData<T extends UnknownAction> = {
+    id: string;
+    action: ActionName<T>;
+    error: Error;
 };
-declare const toSafeKeyPackageStatus: (status: KeyPackageStatus) => SafeKeyPackageStatus;
 
-type ClientStreamEvents = {
-    type: "message";
+type StreamAction = {
+    action: "stream.message";
     streamId: string;
     result: SafeMessage | undefined;
 } | {
-    type: "group";
+    action: "stream.conversation";
     streamId: string;
     result: SafeConversation | undefined;
 } | {
-    type: "consent";
+    action: "stream.consent";
     streamId: string;
     result: SafeConsent[] | undefined;
 } | {
-    type: "preferences";
+    action: "stream.preferences";
     streamId: string;
     result: UserPreference[] | undefined;
 };
 
+/**
+ * Class that sets up a worker and provides communications for client functions
+ *
+ * This class is not meant to be used directly, it is extended by the Client class
+ * to provide an interface to the worker.
+ *
+ * @param worker - The worker to use for the client class
+ * @param enableLogging - Whether to enable logging in the worker
+ * @returns A new ClientWorkerClass instance
+ */
 declare class ClientWorkerClass {
     #private;
     constructor(worker: Worker, enableLogging: boolean);
-    sendMessage<A extends ClientEventsActions>(action: A, data: ClientSendMessageData<A>): Promise<ClientEventsResult<A>>;
-    handleMessage: (event: MessageEvent<ClientEventsWorkerMessageData | ClientEventsErrorData>) => void;
-    handleStreamMessage: <T extends ClientStreamEvents["result"]>(streamId: string, callback: (error: Error | null, value: T | null) => void) => () => void;
+    /**
+     * Sends an action message to the client 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>>;
+    /**
+     * Handles a message from the client worker
+     *
+     * @param event - The event to handle
+     */
+    handleMessage: (event: MessageEvent<ActionWithoutData<ClientWorkerAction> | ActionErrorData<ClientWorkerAction>>) => void;
+    /**
+     * Handles a stream message from the client 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"]>(streamId: string, callback: (error: Error | null, value: T | null) => void) => () => void;
+    /**
+     * Removes all event listeners and terminates the worker
+     */
     close(): void;
 }
 
@@ -1093,9 +1150,9 @@ type MessageDeliveryStatus = "unpublished" | "published" | "failed";
  * @property {string} senderInboxId - Identifier for the sender's inbox
  * @property {bigint} sentAtNs - Timestamp when the message was sent (in nanoseconds)
  */
-declare class DecodedMessage<T = unknown> {
+declare class DecodedMessage<ContentTypes = unknown> {
     #private;
-    content: T | undefined;
+    content: ContentTypes | undefined;
     contentType: ContentTypeId$1;
     conversationId: string;
     deliveryStatus: MessageDeliveryStatus;
@@ -1107,7 +1164,7 @@ declare class DecodedMessage<T = unknown> {
     encodedContent: SafeMessage["content"];
     senderInboxId: string;
     sentAtNs: bigint;
-    constructor(client: Client, message: SafeMessage);
+    constructor(client: Client<ContentTypes>, message: SafeMessage);
 }
 
 /**
@@ -1115,7 +1172,7 @@ declare class DecodedMessage<T = unknown> {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Conversation {
+declare class Conversation<ContentTypes = unknown> {
     #private;
     /**
      * Creates a new conversation instance
@@ -1124,7 +1181,7 @@ declare class Conversation {
      * @param id - The unique identifier for this conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client, id: string, data?: SafeConversation);
+    constructor(client: Client<ContentTypes>, id: string, data?: SafeConversation);
     get id(): string;
     get isActive(): boolean | undefined;
     get addedByInboxId(): string | undefined;
@@ -1151,7 +1208,7 @@ declare class Conversation {
      *
      * @returns Promise that resolves when publishing is complete
      */
-    publishMessages(): Promise<undefined>;
+    publishMessages(): Promise<void>;
     /**
      * Prepares a message to be published
      *
@@ -1160,7 +1217,7 @@ declare class Conversation {
      * @returns Promise that resolves with the message ID
      * @throws {MissingContentTypeError} if content type is required but not provided
      */
-    sendOptimistic(content: unknown, contentType?: ContentTypeId$1): Promise<string>;
+    sendOptimistic(content: ContentTypes, contentType?: ContentTypeId$1): Promise<string>;
     /**
      * Publishes a new message
      *
@@ -1169,14 +1226,14 @@ declare class Conversation {
      * @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: unknown, contentType?: ContentTypeId$1): Promise<string>;
+    send(content: ContentTypes, contentType?: ContentTypeId$1): 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<unknown>[]>;
+    messages(options?: SafeListMessagesOptions): Promise<DecodedMessage<ContentTypes>[]>;
     /**
      * Gets the consent state for this conversation
      *
@@ -1189,7 +1246,7 @@ declare class Conversation {
      * @param state - The new consent state to set
      * @returns Promise that resolves when the update is complete
      */
-    updateConsentState(state: ConsentState): Promise<undefined>;
+    updateConsentState(state: ConsentState): Promise<void>;
     /**
      * Gets the message disappearing settings for this conversation
      *
@@ -1203,13 +1260,13 @@ declare class Conversation {
      * @param inNs - The duration after which messages should disappear
      * @returns Promise that resolves when the update is complete
      */
-    updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint): Promise<undefined>;
+    updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint): Promise<void>;
     /**
      * Removes message disappearing settings from this conversation
      *
      * @returns Promise that resolves when the settings are removed
      */
-    removeMessageDisappearingSettings(): Promise<undefined>;
+    removeMessageDisappearingSettings(): Promise<void>;
     /**
      * Checks if message disappearing is enabled for this conversation
      *
@@ -1222,14 +1279,20 @@ declare class Conversation {
      * @param callback - Optional callback function for handling new stream values
      * @returns Stream instance for new messages
      */
-    stream(callback?: StreamCallback<DecodedMessage>): Promise<AsyncStream<DecodedMessage<unknown>>>;
+    stream(callback?: StreamCallback<DecodedMessage<ContentTypes>>): Promise<AsyncStream<DecodedMessage<ContentTypes>>>;
     pausedForVersion(): Promise<string | undefined>;
     /**
      * Retrieves HMAC keys for this conversation
      *
      * @returns Promise that resolves with the HMAC keys
      */
-    getHmacKeys(): Promise<SafeHmacKey[]>;
+    getHmacKeys(): Promise<Map<string, SafeHmacKey[]>>;
+    /**
+     * Retrieves information for this conversation to help with debugging
+     *
+     * @returns The debug information for this conversation
+     */
+    debugInfo(): Promise<SafeConversationDebugInfo>;
 }
 
 /**
@@ -1237,7 +1300,7 @@ declare class Conversation {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Dm extends Conversation {
+declare class Dm<ContentTypes = unknown> extends Conversation<ContentTypes> {
     #private;
     /**
      * Creates a new direct message conversation instance
@@ -1246,13 +1309,14 @@ declare class Dm extends Conversation {
      * @param id - Identifier for the direct message conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client, id: string, data?: SafeConversation);
+    constructor(client: Client<ContentTypes>, 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[]>;
 }
 
 /**
@@ -1260,7 +1324,7 @@ declare class Dm extends Conversation {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Group extends Conversation {
+declare class Group<ContentTypes = unknown> extends Conversation<ContentTypes> {
     #private;
     /**
      * Creates a new group conversation instance
@@ -1269,7 +1333,7 @@ declare class Group extends Conversation {
      * @param id - Identifier for the group conversation
      * @param data - Optional conversation data to initialize with
      */
-    constructor(client: Client, id: string, data?: SafeConversation);
+    constructor(client: Client<ContentTypes>, id: string, data?: SafeConversation);
     /**
      * Synchronizes the group's data with the network
      *
@@ -1351,7 +1415,7 @@ declare class Group extends Conversation {
      * @param policy The new permission policy
      * @param metadataField Optional metadata field for the permission
      */
-    updatePermission(permissionType: PermissionUpdateType, policy: PermissionPolicy, metadataField?: MetadataField): Promise<undefined>;
+    updatePermission(permissionType: PermissionUpdateType, policy: PermissionPolicy, metadataField?: MetadataField): Promise<void>;
     /**
      * Checks if an inbox is an admin of the group
      *
@@ -1371,49 +1435,49 @@ declare class Group extends Conversation {
      *
      * @param identifiers Array of member identifiers to add
      */
-    addMembersByIdentifiers(identifiers: Identifier[]): Promise<undefined>;
+    addMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
     /**
      * Adds members to the group using inbox IDs
      *
      * @param inboxIds Array of inbox IDs to add
      */
-    addMembers(inboxIds: string[]): Promise<undefined>;
+    addMembers(inboxIds: string[]): Promise<void>;
     /**
      * Removes members from the group using identifiers
      *
      * @param identifiers Array of member identifiers to remove
      */
-    removeMembersByIdentifiers(identifiers: Identifier[]): Promise<undefined>;
+    removeMembersByIdentifiers(identifiers: Identifier[]): Promise<void>;
     /**
      * Removes members from the group using inbox IDs
      *
      * @param inboxIds Array of inbox IDs to remove
      */
-    removeMembers(inboxIds: string[]): Promise<undefined>;
+    removeMembers(inboxIds: string[]): Promise<void>;
     /**
      * Promotes a group member to admin status
      *
      * @param inboxId The inbox ID of the member to promote
      */
-    addAdmin(inboxId: string): Promise<undefined>;
+    addAdmin(inboxId: string): Promise<void>;
     /**
      * Removes admin status from a group member
      *
      * @param inboxId The inbox ID of the admin to demote
      */
-    removeAdmin(inboxId: string): Promise<undefined>;
+    removeAdmin(inboxId: string): Promise<void>;
     /**
      * Promotes a group member to super admin status
      *
      * @param inboxId The inbox ID of the member to promote
      */
-    addSuperAdmin(inboxId: string): Promise<undefined>;
+    addSuperAdmin(inboxId: string): Promise<void>;
     /**
      * Removes super admin status from a group member
      *
      * @param inboxId The inbox ID of the super admin to demote
      */
-    removeSuperAdmin(inboxId: string): Promise<undefined>;
+    removeSuperAdmin(inboxId: string): Promise<void>;
 }
 
 /**
@@ -1421,20 +1485,20 @@ declare class Group extends Conversation {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Conversations {
+declare class Conversations<ContentTypes = unknown> {
     #private;
     /**
      * Creates a new conversations instance
      *
      * @param client - The client instance managing the conversations
      */
-    constructor(client: Client);
+    constructor(client: Client<ContentTypes>);
     /**
      * Synchronizes conversations for the current client from the network
      *
      * @returns Promise that resolves when sync is complete
      */
-    sync(): Promise<undefined>;
+    sync(): Promise<void>;
     /**
      * Synchronizes all conversations and messages from the network with optional
      * consent state filtering, then uploads conversation and message history to
@@ -1443,49 +1507,56 @@ declare class Conversations {
      * @param consentStates - Optional array of consent states to filter by
      * @returns Promise that resolves when sync is complete
      */
-    syncAll(consentStates?: ConsentState[]): Promise<undefined>;
+    syncAll(consentStates?: ConsentState[]): Promise<void>;
     /**
      * Retrieves a conversation by its ID
      *
      * @param id - The conversation ID to look up
      * @returns Promise that resolves with the conversation, if found
      */
-    getConversationById(id: string): Promise<Dm | Group | undefined>;
+    getConversationById(id: string): Promise<Group<ContentTypes> | Dm<ContentTypes> | undefined>;
     /**
      * Retrieves a message by its ID
      *
      * @param id - The message ID to look up
      * @returns Promise that resolves with the decoded message, if found
      */
-    getMessageById<T = unknown>(id: string): Promise<DecodedMessage<T> | undefined>;
+    getMessageById(id: string): Promise<DecodedMessage<ContentTypes> | undefined>;
     /**
      * Retrieves a DM by inbox ID
      *
      * @param inboxId - The inbox ID to look up
      * @returns Promise that resolves with the DM, if found
      */
-    getDmByInboxId(inboxId: string): Promise<Dm | undefined>;
+    getDmByInboxId(inboxId: string): Promise<Dm<ContentTypes> | 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<(Dm | Group)[]>;
+    list(options?: SafeListConversationsOptions): 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[]>;
+    listGroups(options?: Omit<SafeListConversationsOptions, "conversation_type">): 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[]>;
+    listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">): Promise<Dm<ContentTypes>[]>;
+    /**
+     * Creates a new group without syncing to the network
+     *
+     * @param options - Optional group creation options
+     * @returns Promise that resolves with the new group
+     */
+    newGroupOptimistic(options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new group conversation with the specified identifiers
      *
@@ -1493,7 +1564,7 @@ declare class Conversations {
      * @param options - Optional group creation options
      * @returns Promise that resolves with the new group
      */
-    newGroupWithIdentifiers(identifiers: Identifier[], options?: SafeCreateGroupOptions): Promise<Group>;
+    newGroupWithIdentifiers(identifiers: Identifier[], options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new group conversation with the specified inbox IDs
      *
@@ -1501,7 +1572,7 @@ declare class Conversations {
      * @param options - Optional group creation options
      * @returns Promise that resolves with the new group
      */
-    newGroup(inboxIds: string[], options?: SafeCreateGroupOptions): Promise<Group>;
+    newGroup(inboxIds: string[], options?: SafeCreateGroupOptions): Promise<Group<ContentTypes>>;
     /**
      * Creates a new DM conversation with the specified identifier
      *
@@ -1509,7 +1580,7 @@ declare class Conversations {
      * @param options - Optional DM creation options
      * @returns Promise that resolves with the new DM
      */
-    newDmWithIdentifier(identifier: Identifier, options?: SafeCreateDmOptions): Promise<Dm>;
+    newDmWithIdentifier(identifier: Identifier, options?: SafeCreateDmOptions): Promise<Dm<ContentTypes>>;
     /**
      * Creates a new DM conversation with the specified inbox ID
      *
@@ -1517,7 +1588,7 @@ declare class Conversations {
      * @param options - Optional DM creation options
      * @returns Promise that resolves with the new DM
      */
-    newDm(inboxId: string, options?: SafeCreateDmOptions): Promise<Dm>;
+    newDm(inboxId: string, options?: SafeCreateDmOptions): Promise<Dm<ContentTypes>>;
     /**
      * Retrieves HMAC keys for all conversations
      *
@@ -1531,21 +1602,21 @@ declare class Conversations {
      * @param conversationType - Optional type to filter conversations
      * @returns Stream instance for new conversations
      */
-    stream<T extends Group | Dm = Group | Dm>(callback?: StreamCallback<T>, conversationType?: ConversationType): Promise<AsyncStream<T>>;
+    stream<T extends Group<ContentTypes> | Dm<ContentTypes> = Group<ContentTypes> | Dm<ContentTypes>>(callback?: StreamCallback<T>, conversationType?: ConversationType): Promise<AsyncStream<T>>;
     /**
      * Creates a stream for new group conversations
      *
      * @param callback - Optional callback function for handling new stream value
      * @returns Stream instance for new group conversations
      */
-    streamGroups(callback?: StreamCallback<Group>): Promise<AsyncStream<Group>>;
+    streamGroups(callback?: StreamCallback<Group<ContentTypes>>): Promise<AsyncStream<Group<ContentTypes>>>;
     /**
      * Creates a stream for new DM conversations
      *
      * @param callback - Optional callback function for handling new stream value
      * @returns Stream instance for new DM conversations
      */
-    streamDms(callback?: StreamCallback<Dm>): Promise<AsyncStream<Dm>>;
+    streamDms(callback?: StreamCallback<Dm<ContentTypes>>): Promise<AsyncStream<Dm<ContentTypes>>>;
     /**
      * Creates a stream for all new messages
      *
@@ -1553,21 +1624,21 @@ declare class Conversations {
      * @param conversationType - Optional conversation type to filter messages
      * @returns Stream instance for new messages
      */
-    streamAllMessages(callback?: StreamCallback<DecodedMessage>, conversationType?: ConversationType): Promise<AsyncStream<DecodedMessage<unknown>>>;
+    streamAllMessages(callback?: StreamCallback<DecodedMessage<ContentTypes>>, conversationType?: ConversationType, consentStates?: ConsentState[]): Promise<AsyncStream<DecodedMessage<ContentTypes>>>;
     /**
      * Creates a stream for all new group messages
      *
      * @param callback - Optional callback function for handling new stream value
      * @returns Stream instance for new group messages
      */
-    streamAllGroupMessages(callback?: StreamCallback<DecodedMessage>): Promise<AsyncStream<DecodedMessage<unknown>>>;
+    streamAllGroupMessages(callback?: StreamCallback<DecodedMessage<ContentTypes>>, consentStates?: ConsentState[]): Promise<AsyncStream<DecodedMessage<ContentTypes>>>;
     /**
      * Creates a stream for all new DM messages
      *
      * @param callback - Optional callback function for handling new stream value
      * @returns Stream instance for new DM messages
      */
-    streamAllDmMessages(callback?: StreamCallback<DecodedMessage>): Promise<AsyncStream<DecodedMessage<unknown>>>;
+    streamAllDmMessages(callback?: StreamCallback<DecodedMessage<ContentTypes>>, consentStates?: ConsentState[]): Promise<AsyncStream<DecodedMessage<ContentTypes>>>;
 }
 
 /**
@@ -1575,14 +1646,15 @@ declare class Conversations {
  *
  * This class is not intended to be initialized directly.
  */
-declare class Preferences {
+declare class Preferences<ContentTypes = unknown> {
     #private;
     /**
      * Creates a new preferences instance
      *
      * @param client - The client instance managing preferences
      */
-    constructor(client: Client);
+    constructor(client: Client<ContentTypes>);
+    sync(): Promise<number>;
     /**
      * Retrieves the current inbox state
      *
@@ -1611,7 +1683,7 @@ declare class Preferences {
      * @param records - Array of consent records to update
      * @returns Promise that resolves when consent states are updated
      */
-    setConsentStates(records: SafeConsent[]): Promise<undefined>;
+    setConsentStates(records: SafeConsent[]): Promise<void>;
     /**
      * Retrieves consent state for a specific entity
      *
@@ -1652,10 +1724,15 @@ type Signer = {
     getChainId: GetChainId;
 };
 
+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 extends ClientWorkerClass {
+declare class Client<ContentTypes = ExtractCodecContentTypes> extends ClientWorkerClass {
     #private;
     /**
      * Creates a new XMTP client instance
@@ -1682,7 +1759,9 @@ declare class Client extends ClientWorkerClass {
      * @param options - Optional configuration for the client
      * @returns A new client instance
      */
-    static create(signer: Signer, options?: ClientOptions): Promise<Client>;
+    static create<ContentCodecs extends ContentCodec[] = []>(signer: Signer, options?: Omit<ClientOptions, "codecs"> & {
+        codecs?: ContentCodecs;
+    }): Promise<Client<ExtractCodecContentTypes<ContentCodecs>>>;
     /**
      * Creates a new client instance with an identifier
      *
@@ -1693,7 +1772,9 @@ declare class Client extends ClientWorkerClass {
      * @param options - Optional configuration for the client
      * @returns A new client instance
      */
-    static build(identifier: Identifier, options?: ClientOptions): Promise<Client>;
+    static build<ContentCodecs extends ContentCodec[] = []>(identifier: Identifier, options?: Omit<ClientOptions, "codecs"> & {
+        codecs?: ContentCodecs;
+    }): Promise<Client<ExtractCodecContentTypes<ContentCodecs>>>;
     /**
      * Gets the client options
      */
@@ -1725,11 +1806,11 @@ declare class Client extends ClientWorkerClass {
     /**
      * Gets the conversations manager for this client
      */
-    get conversations(): Conversations;
+    get conversations(): Conversations<ContentTypes>;
     /**
      * Gets the preferences manager for this client
      */
-    get preferences(): Preferences;
+    get preferences(): Preferences<ContentTypes>;
     /**
      * Creates signature text for creating a new inbox
      *
@@ -1838,7 +1919,7 @@ declare class Client extends ClientWorkerClass {
      * `removeAccount`, `revokeAllOtherInstallations`, or `revokeInstallations`
      * methods instead.
      */
-    unsafe_applySignatures(): Promise<undefined>;
+    unsafe_applySignatures(): Promise<void>;
     /**
      * Registers the client with the XMTP network
      *
@@ -1846,7 +1927,7 @@ declare class Client extends ClientWorkerClass {
      *
      * @throws {SignerUnavailableError} if no signer is available
      */
-    register(): Promise<undefined>;
+    register(): Promise<void>;
     /**
      * Adds a new account to the client inbox
      *
@@ -1939,7 +2020,7 @@ declare class Client extends ClientWorkerClass {
      * @param contentType - The content type to get the codec for
      * @returns The codec, if found
      */
-    codecFor<T = unknown>(contentType: ContentTypeId$1): ContentCodec<T> | undefined;
+    codecFor<ContentType = unknown>(contentType: ContentTypeId$1): ContentCodec<ContentType> | undefined;
     /**
      * Encodes content for a given content type
      *
@@ -1948,7 +2029,7 @@ declare class Client extends ClientWorkerClass {
      * @returns The encoded content
      * @throws {CodecNotFoundError} if no codec is found for the content type
      */
-    encodeContent(content: unknown, contentType: ContentTypeId$1): SafeEncodedContent;
+    encodeContent(content: ContentTypes, contentType: ContentTypeId$1): SafeEncodedContent;
     /**
      * Decodes a message for a given content type
      *
@@ -1958,7 +2039,7 @@ declare class Client extends ClientWorkerClass {
      * @throws {CodecNotFoundError} if no codec is found for the content type
      * @throws {InvalidGroupMembershipChangeError} if the message is an invalid group membership change
      */
-    decodeContent<T = unknown>(message: SafeMessage, contentType: ContentTypeId$1): T;
+    decodeContent<ContentType = unknown>(message: SafeMessage, contentType: ContentTypeId$1): ContentType;
     /**
      * Signs a message with the installation key
      *
@@ -1990,14 +2071,73 @@ declare class Client extends ClientWorkerClass {
      * @returns The key package statuses
      */
     getKeyPackageStatusesForInstallationIds(installationIds: string[]): Promise<Map<string, SafeKeyPackageStatus>>;
+    apiStatistics(): Promise<SafeApiStats>;
+    apiIdentityStatistics(): Promise<SafeIdentityStats>;
+    apiAggregateStatistics(): Promise<string>;
+    uploadDebugArchive(serverUrl?: string): Promise<string>;
 }
 
+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;
+    };
+};
+
+/**
+ * Class that sets up a worker and provides communications for utility functions
+ *
+ * This class is not meant to be used directly, it is extended by the Utils class
+ * to provide an interface to the worker.
+ *
+ * @param worker - The worker to use for the utils class
+ * @param enableLogging - Whether to enable logging in the worker
+ * @returns A new UtilsWorkerClass instance
+ */
 declare class UtilsWorkerClass {
     #private;
     constructor(worker: Worker, enableLogging: boolean);
-    init(enableLogging: boolean): Promise<undefined>;
-    sendMessage<A extends UtilsEventsActions>(action: A, data: UtilsSendMessageData<A>): Promise<UtilsEventsResult<A>>;
-    handleMessage: (event: MessageEvent<UtilsEventsWorkerMessageData | UtilsEventsErrorData>) => void;
+    /**
+     * Initializes the utils worker
+     *
+     * @param enableLogging - Whether to enable logging in the worker
+     * @returns A promise that resolves when the worker is initialized
+     */
+    init(enableLogging: boolean): 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;
 }
 
@@ -2028,4 +2168,35 @@ declare class Utils extends UtilsWorkerClass {
     getInboxIdForIdentifier(identifier: Identifier, env?: XmtpEnv): Promise<string | undefined>;
 }
 
-export { ApiUrls, AsyncStream, Client, type ClientEvents, type ClientEventsActions, type ClientEventsClientMessageData, type ClientEventsClientPostMessageData, type ClientEventsErrorData, type ClientEventsResult, type ClientEventsWorkerMessageData, type ClientEventsWorkerPostMessageData, type ClientOptions, type ClientSendMessageData, type ContentOptions, Conversation, Conversations, DecodedMessage, Dm, type EventsClientMessageData, type EventsClientPostMessageData, type EventsErrorData, type EventsResult, type EventsWorkerMessageData, type EventsWorkerPostMessageData, type GenericEvent, type GenericStreamEvent, Group, HistorySyncUrls, type HmacKeys, type MessageDeliveryStatus, type MessageKind, type NetworkOptions, type OtherOptions, type SafeConsent, type SafeContentTypeId, type SafeConversation, type SafeCreateDmOptions, type SafeCreateGroupOptions, type SafeEncodedContent, type SafeGroupMember, type SafeHmacKey, type SafeHmacKeys, type SafeInboxState, type SafeInstallation, type SafeKeyPackageStatus, type SafeListConversationsOptions, type SafeListMessagesOptions, type SafeMessage, type SafeMessageDisappearingSettings, type SafePermissionPolicySet, type SendMessageData, type Signer, type StorageOptions, type StreamCallback, type StreamEventsClientMessageData, type StreamEventsClientPostMessageData, type StreamEventsErrorData, type StreamEventsResult, Utils, type UtilsEvents, type UtilsEventsActions, type UtilsEventsClientMessageData, type UtilsEventsClientPostMessageData, type UtilsEventsErrorData, type UtilsEventsResult, type UtilsEventsWorkerMessageData, type UtilsEventsWorkerPostMessageData, type UtilsSendMessageData, type XmtpEnv, fromContentTypeId, fromEncodedContent, fromSafeConsent, fromSafeContentTypeId, fromSafeCreateDmOptions, fromSafeCreateGroupOptions, fromSafeEncodedContent, fromSafeGroupMember, fromSafeListConversationsOptions, fromSafeListMessagesOptions, fromSafeMessageDisappearingSettings, fromSafePermissionPolicySet, toContentTypeId, toEncodedContent, toSafeConsent, toSafeContentTypeId, toSafeConversation, toSafeCreateDmOptions, toSafeCreateGroupOptions, toSafeEncodedContent, toSafeGroupMember, toSafeHmacKey, toSafeInboxState, toSafeInstallation, toSafeKeyPackageStatus, toSafeListConversationsOptions, toSafeListMessagesOptions, toSafeMessage, toSafeMessageDisappearingSettings, toSafePermissionPolicySet };
+declare class ClientNotInitializedError extends Error {
+    constructor();
+}
+declare class SignerUnavailableError extends Error {
+    constructor();
+}
+declare class CodecNotFoundError extends Error {
+    constructor(contentType: ContentTypeId$1);
+}
+declare class InboxReassignError extends Error {
+    constructor();
+}
+declare class AccountAlreadyAssociatedError extends Error {
+    constructor(inboxId: string);
+}
+declare class GenerateSignatureError extends Error {
+    constructor(signatureType: SignatureRequestType);
+}
+declare class GroupNotFoundError extends Error {
+    constructor(groupId: string);
+}
+declare class StreamNotFoundError extends Error {
+    constructor(streamId: string);
+}
+declare class InvalidGroupMembershipChangeError extends Error {
+    constructor(messageId: string);
+}
+declare class MissingContentTypeError extends Error {
+    constructor();
+}
+
+export { AccountAlreadyAssociatedError, ApiUrls, AsyncStream, Client, ClientNotInitializedError, type ClientOptions, CodecNotFoundError, type ContentOptions, Conversation, Conversations, DecodedMessage, Dm, type ExtractCodecContentTypes, GenerateSignatureError, Group, GroupNotFoundError, HistorySyncUrls, type HmacKeys, InboxReassignError, InvalidGroupMembershipChangeError, type MessageDeliveryStatus, type MessageKind, MissingContentTypeError, type NetworkOptions, type OtherOptions, type SafeApiStats, type SafeConsent, type SafeContentTypeId, type SafeConversation, type SafeConversationDebugInfo, type SafeCreateDmOptions, type SafeCreateGroupOptions, type SafeEncodedContent, type SafeGroupMember, type SafeHmacKey, type SafeHmacKeys, type SafeIdentityStats, type SafeInboxState, type SafeInstallation, type SafeKeyPackageStatus, type SafeListConversationsOptions, type SafeListMessagesOptions, type SafeMessage, type SafeMessageDisappearingSettings, type SafePermissionPolicySet, type Signer, SignerUnavailableError, type StorageOptions, type StreamCallback, StreamNotFoundError, Utils, type XmtpEnv, fromContentTypeId, fromEncodedContent, fromSafeConsent, fromSafeContentTypeId, fromSafeCreateDmOptions, fromSafeCreateGroupOptions, fromSafeEncodedContent, fromSafeGroupMember, fromSafeListConversationsOptions, fromSafeListMessagesOptions, fromSafeMessageDisappearingSettings, fromSafePermissionPolicySet, toContentTypeId, toEncodedContent, toSafeApiStats, toSafeConsent, toSafeContentTypeId, toSafeConversation, toSafeConversationDebugInfo, toSafeCreateDmOptions, toSafeCreateGroupOptions, toSafeEncodedContent, toSafeGroupMember, toSafeHmacKey, toSafeIdentityStats, toSafeInboxState, toSafeInstallation, toSafeKeyPackageStatus, toSafeListConversationsOptions, toSafeListMessagesOptions, toSafeMessage, toSafeMessageDisappearingSettings, toSafePermissionPolicySet };