@xmtp/browser-sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,791 @@
+import * as _xmtp_wasm_bindings from '@xmtp/wasm-bindings';
+import { WasmSignatureRequestType, WasmConsentState, WasmConsentEntityType, WasmConversations, WasmClient, WasmGroup, WasmGroupMember, WasmEncodedContent, WasmContentTypeId, WasmDeliveryStatus, WasmGroupMessageKind, WasmMessage, WasmListMessagesOptions, WasmListConversationsOptions, WasmGroupPermissionsOptions, WasmCreateGroupOptions, WasmPermissionPolicy, WasmInstallation, WasmInboxState, WasmConsent, WasmPermissionLevel } from '@xmtp/wasm-bindings';
+export * from '@xmtp/wasm-bindings';
+import { ContentCodec, ContentTypeId, EncodedContent } from '@xmtp/content-type-primitives';
+
+declare const ApiUrls: {
+    readonly local: "http://localhost:5555";
+    readonly dev: "https://dev.xmtp.network";
+    readonly production: "https://production.xmtp.network";
+};
+
+type XmtpEnv = keyof typeof ApiUrls;
+/**
+ * Network options
+ */
+type NetworkOptions = {
+    /**
+     * Specify which XMTP environment to connect to. (default: `dev`)
+     */
+    env?: XmtpEnv;
+    /**
+     * apiUrl can be used to override the `env` flag and connect to a
+     * specific endpoint
+     */
+    apiUrl?: string;
+};
+/**
+ * Encryption options
+ */
+type EncryptionOptions = {
+    /**
+     * Encryption key to use for the local DB
+     */
+    encryptionKey?: Uint8Array;
+};
+/**
+ * Storage options
+ */
+type StorageOptions = {
+    /**
+     * Path to the local DB
+     */
+    dbPath?: string;
+};
+type ContentOptions = {
+    /**
+     * Allow configuring codecs for additional content types
+     */
+    codecs?: ContentCodec[];
+};
+type OtherOptions = {
+    /**
+     * Enable logging of events between the client and worker
+     */
+    enableLogging?: boolean;
+};
+type ClientOptions = NetworkOptions & EncryptionOptions & StorageOptions & ContentOptions & OtherOptions;
+
+type ClientEvents = 
+/**
+ * Client actions
+ */
+{
+    action: "init";
+    id: string;
+    result: {
+        inboxId: string;
+        installationId: string;
+    };
+    data: {
+        address: string;
+        options?: ClientOptions;
+    };
+} | {
+    action: "getCreateInboxSignatureText";
+    id: string;
+    result: string | undefined;
+    data: undefined;
+} | {
+    action: "getAddWalletSignatureText";
+    id: string;
+    result: string | undefined;
+    data: {
+        accountAddress: string;
+    };
+} | {
+    action: "getRevokeWalletSignatureText";
+    id: string;
+    result: string | undefined;
+    data: {
+        accountAddress: string;
+    };
+} | {
+    action: "getRevokeInstallationsSignatureText";
+    id: string;
+    result: string | undefined;
+    data: undefined;
+} | {
+    action: "addSignature";
+    id: string;
+    result: undefined;
+    data: {
+        type: WasmSignatureRequestType;
+        bytes: Uint8Array;
+    };
+} | {
+    action: "applySignaturesRequests";
+    id: string;
+    result: undefined;
+    data: undefined;
+} | {
+    action: "registerIdentity";
+    id: string;
+    result: undefined;
+    data: undefined;
+} | {
+    action: "isRegistered";
+    id: string;
+    result: boolean;
+    data: undefined;
+} | {
+    action: "canMessage";
+    id: string;
+    result: Map<string, boolean>;
+    data: {
+        accountAddresses: string[];
+    };
+} | {
+    action: "inboxState";
+    id: string;
+    result: SafeInboxState;
+    data: {
+        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: WasmConsentState;
+    data: {
+        entityType: WasmConsentEntityType;
+        entity: string;
+    };
+} | {
+    action: "findInboxIdByAddress";
+    id: string;
+    result: string | undefined;
+    data: {
+        address: string;
+    };
+}
+/**
+ * Conversations actions
+ */
+ | {
+    action: "getConversationById";
+    id: string;
+    result: SafeConversation | undefined;
+    data: {
+        id: string;
+    };
+} | {
+    action: "getMessageById";
+    id: string;
+    result: SafeMessage | undefined;
+    data: {
+        id: string;
+    };
+} | {
+    action: "getConversations";
+    id: string;
+    result: SafeConversation[];
+    data: {
+        options?: SafeListConversationsOptions;
+    };
+} | {
+    action: "newGroup";
+    id: string;
+    result: SafeConversation;
+    data: {
+        accountAddresses: string[];
+        options?: SafeCreateGroupOptions;
+    };
+} | {
+    action: "syncConversations";
+    id: string;
+    result: undefined;
+    data: undefined;
+}
+/**
+ * Group actions
+ */
+ | {
+    action: "syncGroup";
+    id: string;
+    result: SafeConversation;
+    data: {
+        id: string;
+    };
+} | {
+    action: "sendGroupMessage";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        content: SafeEncodedContent;
+    };
+} | {
+    action: "sendOptimisticGroupMessage";
+    id: string;
+    result: string;
+    data: {
+        id: string;
+        content: SafeEncodedContent;
+    };
+} | {
+    action: "publishGroupMessages";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+    };
+} | {
+    action: "getGroupMessages";
+    id: string;
+    result: SafeMessage[];
+    data: {
+        id: string;
+        options?: SafeListMessagesOptions;
+    };
+} | {
+    action: "getGroupMembers";
+    id: string;
+    result: SafeGroupMember[];
+    data: {
+        id: string;
+    };
+} | {
+    action: "getGroupAdmins";
+    id: string;
+    result: string[];
+    data: {
+        id: string;
+    };
+} | {
+    action: "getGroupSuperAdmins";
+    id: string;
+    result: string[];
+    data: {
+        id: string;
+    };
+} | {
+    action: "isGroupAdmin";
+    id: string;
+    result: boolean;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "isGroupSuperAdmin";
+    id: string;
+    result: boolean;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "addGroupMembers";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        accountAddresses: string[];
+    };
+} | {
+    action: "removeGroupMembers";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        accountAddresses: string[];
+    };
+} | {
+    action: "addGroupMembersByInboxId";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxIds: string[];
+    };
+} | {
+    action: "removeGroupMembersByInboxId";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxIds: string[];
+    };
+} | {
+    action: "addGroupAdmin";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "removeGroupAdmin";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "addGroupSuperAdmin";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "removeGroupSuperAdmin";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        inboxId: string;
+    };
+} | {
+    action: "updateGroupName";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        name: string;
+    };
+} | {
+    action: "updateGroupDescription";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        description: string;
+    };
+} | {
+    action: "updateGroupImageUrlSquare";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        imageUrl: string;
+    };
+} | {
+    action: "updateGroupPinnedFrameUrl";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        pinnedFrameUrl: string;
+    };
+} | {
+    action: "getGroupConsentState";
+    id: string;
+    result: WasmConsentState;
+    data: {
+        id: string;
+    };
+} | {
+    action: "updateGroupConsentState";
+    id: string;
+    result: undefined;
+    data: {
+        id: string;
+        state: WasmConsentState;
+    };
+};
+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: "generateInboxId";
+    id: string;
+    result: string;
+    data: {
+        address: string;
+        enableLogging: boolean;
+    };
+} | {
+    action: "getInboxIdForAddress";
+    id: string;
+    result: string | undefined;
+    data: {
+        address: string;
+        env?: XmtpEnv;
+        enableLogging: boolean;
+    };
+};
+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;
+    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: string;
+};
+
+declare class WorkerConversations {
+    #private;
+    constructor(client: WorkerClient, conversations: WasmConversations);
+    sync(): Promise<void>;
+    getConversationById(id: string): WorkerConversation | undefined;
+    getMessageById(id: string): SafeMessage | undefined;
+    list(options?: SafeListConversationsOptions): Promise<WorkerConversation[]>;
+    newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions): Promise<WorkerConversation>;
+}
+
+declare class WorkerClient {
+    #private;
+    constructor(client: WasmClient);
+    static create(accountAddress: string, options?: Omit<ClientOptions, "codecs">): Promise<WorkerClient>;
+    get accountAddress(): string;
+    get inboxId(): string;
+    get installationId(): string;
+    get isRegistered(): boolean;
+    getCreateInboxSignatureText(): Promise<string | undefined>;
+    getAddWalletSignatureText(accountAddress: string): Promise<string | undefined>;
+    getRevokeWalletSignatureText(accountAddress: string): Promise<string | undefined>;
+    getRevokeInstallationsSignatureText(): Promise<string | undefined>;
+    addSignature(type: WasmSignatureRequestType, bytes: Uint8Array): Promise<void>;
+    applySignaturesRequests(): Promise<void>;
+    canMessage(accountAddresses: string[]): Promise<Map<string, boolean>>;
+    registerIdentity(): Promise<void>;
+    findInboxIdByAddress(address: string): Promise<string | undefined>;
+    inboxState(refreshFromNetwork: boolean): Promise<_xmtp_wasm_bindings.WasmInboxState>;
+    getLatestInboxState(inboxId: string): Promise<_xmtp_wasm_bindings.WasmInboxState>;
+    setConsentStates(records: SafeConsent[]): Promise<void>;
+    getConsentState(entityType: WasmConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.WasmConsentState>;
+    get conversations(): WorkerConversations;
+}
+
+declare class WorkerConversation {
+    #private;
+    constructor(client: WorkerClient, group: WasmGroup);
+    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 pinnedFrameUrl(): string;
+    updatePinnedFrameUrl(pinnedFrameUrl: string): Promise<void>;
+    get isActive(): boolean;
+    get addedByInboxId(): string;
+    get createdAtNs(): bigint;
+    get metadata(): {
+        creatorInboxId: string;
+        conversationType: string;
+    };
+    members(): Promise<WasmGroupMember[]>;
+    get admins(): string[];
+    get superAdmins(): string[];
+    get permissions(): {
+        policyType: _xmtp_wasm_bindings.WasmGroupPermissionsOptions;
+        policySet: _xmtp_wasm_bindings.WasmPermissionPolicySet;
+    };
+    isAdmin(inboxId: string): boolean;
+    isSuperAdmin(inboxId: string): boolean;
+    sync(): Promise<void>;
+    addMembers(accountAddresses: string[]): Promise<void>;
+    addMembersByInboxId(inboxIds: string[]): Promise<void>;
+    removeMembers(accountAddresses: string[]): Promise<void>;
+    removeMembersByInboxId(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: WasmEncodedContent): string;
+    send(encodedContent: WasmEncodedContent): Promise<string>;
+    messages(options?: SafeListMessagesOptions): _xmtp_wasm_bindings.WasmMessage[];
+    get consentState(): WasmConsentState;
+    updateConsentState(state: WasmConsentState): void;
+}
+
+declare const toContentTypeId: (contentTypeId: WasmContentTypeId) => ContentTypeId;
+declare const fromContentTypeId: (contentTypeId: ContentTypeId) => WasmContentTypeId;
+type SafeContentTypeId = {
+    authorityId: string;
+    typeId: string;
+    versionMajor: number;
+    versionMinor: number;
+};
+declare const toSafeContentTypeId: (contentTypeId: ContentTypeId) => SafeContentTypeId;
+declare const fromSafeContentTypeId: (contentTypeId: SafeContentTypeId) => ContentTypeId;
+declare const toEncodedContent: (content: WasmEncodedContent) => EncodedContent;
+declare const fromEncodedContent: (content: EncodedContent) => WasmEncodedContent;
+type SafeEncodedContent = {
+    type: SafeContentTypeId;
+    parameters: Record<string, string>;
+    fallback?: string;
+    compression?: number;
+    content: Uint8Array;
+};
+declare const toSafeEncodedContent: (content: EncodedContent) => SafeEncodedContent;
+declare const fromSafeEncodedContent: (content: SafeEncodedContent) => EncodedContent;
+type SafeMessage = {
+    content: SafeEncodedContent;
+    convoId: string;
+    deliveryStatus: WasmDeliveryStatus;
+    id: string;
+    kind: WasmGroupMessageKind;
+    senderInboxId: string;
+    sentAtNs: bigint;
+};
+declare const toSafeMessage: (message: WasmMessage) => SafeMessage;
+type SafeListMessagesOptions = {
+    delivery_status?: WasmDeliveryStatus;
+    limit?: bigint;
+    sent_after_ns?: bigint;
+    sent_before_ns?: bigint;
+};
+declare const toSafeListMessagesOptions: (options: WasmListMessagesOptions) => SafeListMessagesOptions;
+declare const fromSafeListMessagesOptions: (options: SafeListMessagesOptions) => WasmListMessagesOptions;
+type SafeListConversationsOptions = {
+    created_after_ns?: bigint;
+    created_before_ns?: bigint;
+    limit?: bigint;
+};
+declare const toSafeListConversationsOptions: (options: WasmListConversationsOptions) => SafeListConversationsOptions;
+declare const fromSafeListConversationsOptions: (options: SafeListConversationsOptions) => WasmListConversationsOptions;
+type SafeCreateGroupOptions = {
+    permissions?: WasmGroupPermissionsOptions;
+    name?: string;
+    imageUrlSquare?: string;
+    description?: string;
+    pinnedFrameUrl?: string;
+};
+declare const toSafeCreateGroupOptions: (options: WasmCreateGroupOptions) => SafeCreateGroupOptions;
+declare const fromSafeCreateGroupOptions: (options: SafeCreateGroupOptions) => WasmCreateGroupOptions;
+type SafeConversation = {
+    id: string;
+    name: string;
+    imageUrl: string;
+    description: string;
+    pinnedFrameUrl: string;
+    permissions: {
+        policyType: WasmGroupPermissionsOptions;
+        policySet: {
+            addAdminPolicy: WasmPermissionPolicy;
+            addMemberPolicy: WasmPermissionPolicy;
+            removeAdminPolicy: WasmPermissionPolicy;
+            removeMemberPolicy: WasmPermissionPolicy;
+            updateGroupDescriptionPolicy: WasmPermissionPolicy;
+            updateGroupImageUrlSquarePolicy: WasmPermissionPolicy;
+            updateGroupNamePolicy: WasmPermissionPolicy;
+            updateGroupPinnedFrameUrlPolicy: WasmPermissionPolicy;
+        };
+    };
+    isActive: boolean;
+    addedByInboxId: string;
+    metadata: {
+        creatorInboxId: string;
+        conversationType: string;
+    };
+    admins: string[];
+    superAdmins: string[];
+    createdAtNs: bigint;
+};
+declare const toSafeConversation: (conversation: WorkerConversation) => SafeConversation;
+type SafeInstallation = {
+    id: string;
+    clientTimestampNs?: bigint;
+};
+declare const toSafeInstallation: (installation: WasmInstallation) => SafeInstallation;
+type SafeInboxState = {
+    accountAddresses: string[];
+    inboxId: string;
+    installations: SafeInstallation[];
+    recoveryAddress: string;
+};
+declare const toSafeInboxState: (inboxState: WasmInboxState) => SafeInboxState;
+type SafeConsent = {
+    entity: string;
+    entityType: WasmConsentEntityType;
+    state: WasmConsentState;
+};
+declare const toSafeConsent: (consent: WasmConsent) => SafeConsent;
+declare const fromSafeConsent: (consent: SafeConsent) => WasmConsent;
+type SafeGroupMember = {
+    accountAddresses: string[];
+    consentState: WasmConsentState;
+    inboxId: string;
+    installationIds: string[];
+    permissionLevel: WasmPermissionLevel;
+};
+declare const toSafeGroupMember: (member: WasmGroupMember) => SafeGroupMember;
+declare const fromSafeGroupMember: (member: SafeGroupMember) => WasmGroupMember;
+
+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;
+    close(): void;
+}
+
+type MessageKind = "application" | "membership_change";
+type MessageDeliveryStatus = "unpublished" | "published" | "failed";
+declare class DecodedMessage {
+    #private;
+    content: any;
+    contentType: ContentTypeId;
+    conversationId: string;
+    deliveryStatus: MessageDeliveryStatus;
+    fallback?: string;
+    compression?: number;
+    id: string;
+    kind: MessageKind;
+    parameters: Map<string, string>;
+    senderInboxId: string;
+    sentAtNs: bigint;
+    constructor(client: Client, message: SafeMessage);
+}
+
+declare class Conversation {
+    #private;
+    constructor(client: Client, id: string, data?: SafeConversation);
+    get id(): string;
+    get name(): string | undefined;
+    updateName(name: string): Promise<void>;
+    get imageUrl(): string | undefined;
+    updateImageUrl(imageUrl: string): Promise<void>;
+    get description(): string | undefined;
+    updateDescription(description: string): Promise<void>;
+    get pinnedFrameUrl(): string | undefined;
+    updatePinnedFrameUrl(pinnedFrameUrl: string): Promise<void>;
+    get isActive(): boolean | undefined;
+    get addedByInboxId(): string | undefined;
+    get createdAtNs(): bigint | undefined;
+    get createdAt(): Date | undefined;
+    get metadata(): {
+        creatorInboxId: string;
+        conversationType: string;
+    } | undefined;
+    members(): Promise<SafeGroupMember[]>;
+    admins(): Promise<string[]>;
+    superAdmins(): Promise<string[]>;
+    get permissions(): {
+        policyType: _xmtp_wasm_bindings.WasmGroupPermissionsOptions;
+        policySet: {
+            addAdminPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            addMemberPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            removeAdminPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            removeMemberPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            updateGroupDescriptionPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            updateGroupImageUrlSquarePolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            updateGroupNamePolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+            updateGroupPinnedFrameUrlPolicy: _xmtp_wasm_bindings.WasmPermissionPolicy;
+        };
+    } | undefined;
+    isAdmin(inboxId: string): Promise<boolean>;
+    isSuperAdmin(inboxId: string): Promise<boolean>;
+    sync(): Promise<void>;
+    addMembers(accountAddresses: string[]): Promise<undefined>;
+    addMembersByInboxId(inboxIds: string[]): Promise<undefined>;
+    removeMembers(accountAddresses: string[]): Promise<undefined>;
+    removeMembersByInboxId(inboxIds: string[]): Promise<undefined>;
+    addAdmin(inboxId: string): Promise<undefined>;
+    removeAdmin(inboxId: string): Promise<undefined>;
+    addSuperAdmin(inboxId: string): Promise<undefined>;
+    removeSuperAdmin(inboxId: string): Promise<undefined>;
+    publishMessages(): Promise<undefined>;
+    sendOptimistic(content: any, contentType?: ContentTypeId): Promise<string>;
+    send(content: any, contentType?: ContentTypeId): Promise<string>;
+    messages(options?: SafeListMessagesOptions): Promise<DecodedMessage[]>;
+    consentState(): Promise<WasmConsentState>;
+    updateConsentState(state: WasmConsentState): Promise<undefined>;
+}
+
+declare class Conversations {
+    #private;
+    constructor(client: Client);
+    sync(): Promise<undefined>;
+    getConversationById(id: string): Promise<SafeConversation | undefined>;
+    getMessageById(id: string): Promise<SafeMessage | undefined>;
+    list(options?: SafeListConversationsOptions): Promise<Conversation[]>;
+    newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions): Promise<Conversation>;
+}
+
+declare class Client extends ClientWorkerClass {
+    #private;
+    address: string;
+    options?: ClientOptions;
+    constructor(address: string, options?: ClientOptions);
+    init(): Promise<void>;
+    static create(address: string, options?: ClientOptions): Promise<Client>;
+    get isReady(): boolean;
+    get inboxId(): string | undefined;
+    get installationId(): string | undefined;
+    getCreateInboxSignatureText(): Promise<string | undefined>;
+    getAddWalletSignatureText(accountAddress: string): Promise<string | undefined>;
+    getRevokeWalletSignatureText(accountAddress: string): Promise<string | undefined>;
+    addSignature(type: WasmSignatureRequestType, bytes: Uint8Array): Promise<undefined>;
+    applySignaturesRequests(): Promise<undefined>;
+    registerIdentity(): Promise<undefined>;
+    isRegistered(): Promise<boolean>;
+    canMessage(accountAddresses: string[]): Promise<Map<string, boolean>>;
+    findInboxIdByAddress(address: string): Promise<string | undefined>;
+    inboxState(refreshFromNetwork: boolean): Promise<SafeInboxState>;
+    getLatestInboxState(inboxId: string): Promise<SafeInboxState>;
+    setConsentStates(records: SafeConsent[]): Promise<undefined>;
+    getConsentState(entityType: WasmConsentEntityType, entity: string): Promise<_xmtp_wasm_bindings.WasmConsentState>;
+    get conversations(): Conversations;
+    codecFor(contentType: ContentTypeId): ContentCodec | undefined;
+    encodeContent(content: any, contentType: ContentTypeId): SafeEncodedContent;
+    decodeContent(message: SafeMessage, contentType: ContentTypeId): any;
+}
+
+declare class UtilsWorkerClass {
+    #private;
+    constructor(worker: Worker, enableLogging: boolean);
+    sendMessage<A extends UtilsEventsActions>(action: A, data: UtilsSendMessageData<A>): Promise<UtilsEventsResult<A>>;
+    handleMessage: (event: MessageEvent<UtilsEventsWorkerMessageData | UtilsEventsErrorData>) => void;
+    close(): void;
+}
+
+declare class Utils extends UtilsWorkerClass {
+    #private;
+    constructor(enableLogging?: boolean);
+    generateInboxId(address: string): Promise<string>;
+    getInboxIdForAddress(address: string, env?: XmtpEnv): Promise<string | undefined>;
+}
+
+export { ApiUrls, 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, type EncryptionOptions, type EventsClientMessageData, type EventsClientPostMessageData, type EventsErrorData, type EventsResult, type EventsWorkerMessageData, type EventsWorkerPostMessageData, type GenericEvent, type MessageDeliveryStatus, type MessageKind, type NetworkOptions, type OtherOptions, type SafeConsent, type SafeContentTypeId, type SafeConversation, type SafeCreateGroupOptions, type SafeEncodedContent, type SafeGroupMember, type SafeInboxState, type SafeInstallation, type SafeListConversationsOptions, type SafeListMessagesOptions, type SafeMessage, type SendMessageData, type StorageOptions, 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, fromSafeCreateGroupOptions, fromSafeEncodedContent, fromSafeGroupMember, fromSafeListConversationsOptions, fromSafeListMessagesOptions, toContentTypeId, toEncodedContent, toSafeConsent, toSafeContentTypeId, toSafeConversation, toSafeCreateGroupOptions, toSafeEncodedContent, toSafeGroupMember, toSafeInboxState, toSafeInstallation, toSafeListConversationsOptions, toSafeListMessagesOptions, toSafeMessage };