@vex-chat/libvex 1.1.0 → 4.0.0

package/dist/Client.d.ts

@@ -1,39 +1,8 @@
-import type { IChannel, IDevice, IEmoji, IFileResponse, IFileSQL, IInvite, IPermission, IServer, ISessionSQL } from "@vex-chat/types";
-import { AxiosError } from "axios";
-import { EventEmitter } from "eventemitter3";
-import type { IClientAdapters } from "./transport/types.js";
-import type { IStorage } from "./IStorage.js";
+import type { Storage } from "./Storage.js";
+import type { Channel, Device, Emoji, FileResponse, FileSQL, Invite, Permission, Server, SessionSQL } from "@vex-chat/types";
+import { type AxiosError } from "axios";
 /**
- * IMessage is a chat message.
- */
-export interface IMessage {
-    /** Hex-encoded nonce used for message encryption. */
-    nonce: string;
-    /** Globally unique message identifier. */
-    mailID: string;
-    /** Sender device ID. */
-    sender: string;
-    /** Recipient device ID. */
-    recipient: string;
-    /** Plaintext message content (or empty string when decryption failed). */
-    message: string;
-    /** Whether this message was received or sent by the current client. */
-    direction: "incoming" | "outgoing";
-    /** Time the message was created/received. */
-    timestamp: Date;
-    /** Whether payload decryption succeeded. */
-    decrypted: boolean;
-    /** Channel ID for group messages; `null` for direct messages. */
-    group: string | null;
-    /** `true` when this message was forwarded to another owned device. */
-    forward: boolean;
-    /** User ID of the original author. */
-    authorID: string;
-    /** User ID of the intended reader. */
-    readerID: string;
-}
-/**
- * IPermission is a permission to a resource.
+ * Permission is a permission to a resource.
  *
  * Common fields:
  * - `permissionID`: unique permission row ID
@@ -42,16 +11,21 @@ export interface IMessage {
  * - `resourceType`: type string for the resource
  * - `powerLevel`: authorization level
  */
-export type { IPermission } from "@vex-chat/types";
+export type { Permission } from "@vex-chat/types";
 /**
- * IKeys are a pair of ed25519 public and private keys,
- * encoded as hex strings.
+ * @ignore
  */
-export interface IKeys {
-    /** Public Ed25519 key as hex. */
-    public: string;
-    /** Secret Ed25519 key as hex. Store securely. */
-    private: string;
+export interface Channels {
+    /** Creates a channel in a server. */
+    create: (name: string, serverID: string) => Promise<Channel>;
+    /** Deletes a channel. */
+    delete: (channelID: string) => Promise<void>;
+    /** Lists channels in a server. */
+    retrieve: (serverID: string) => Promise<Channel[]>;
+    /** Gets one channel by ID. */
+    retrieveByID: (channelID: string) => Promise<Channel | null>;
+    /** Lists users currently visible in a channel. */
+    userList: (channelID: string) => Promise<User[]>;
 }
 /**
  * Device record associated with a user account.
@@ -64,99 +38,89 @@ export interface IKeys {
  * - `lastLogin`: last login timestamp string
  * - `deleted`: soft-delete flag
  */
-export type { IDevice } from "@vex-chat/types";
+export type { Device } from "@vex-chat/types";
 /**
- * IUser is a single user on the vex platform.
- *
- * This is intentionally a censored user shape for client use, containing:
- * - `userID`
- * - `username`
- * - `lastSeen`
+ * ClientOptions are the options you can pass into the client.
  */
-export interface IUser {
-    /** Last-seen timestamp (unix epoch milliseconds). */
-    lastSeen: number;
-    /** User identifier. */
-    userID: string;
-    /** Public username. */
-    username: string;
+export interface ClientOptions {
+    /** Folder path where the sqlite file is created. */
+    dbFolder?: string;
+    /** Platform label for device registration (e.g. "ios", "macos", "linux"). */
+    deviceName?: string;
+    /** API host without protocol. Defaults to `api.vex.wtf`. */
+    host?: string;
+    /** Use sqlite in-memory mode (`:memory:`) instead of a file. */
+    inMemoryDb?: boolean;
+    /** Whether local message history should be persisted by default storage. */
+    saveHistory?: boolean;
+    /** Use `http/ws` instead of `https/wss`. Intended for local/dev environments. */
+    unsafeHttp?: boolean;
 }
 /**
- * ISession is an end to end encryption session with another peer.
- *
- * Key fields include:
- * - `sessionID`
- * - `userID`
- * - `deviceID`
- * - `mode` (`initiator` or `receiver`)
- * - `publicKey` and `fingerprint`
- * - `lastUsed`
- * - `verified`
- *
- * @example
- * ```ts
- * const session: ISession = {
- *     sessionID: "f6e4fbd0-7222-4ba8-b799-c227faf5c8de",
- *     userID: "f34f5e37-616f-4d3a-a437-e7c27c31cb73",
- *     deviceID: "9b0f3f46-06ad-4bc4-8adf-4de10e13cb9c",
- *     mode: "initiator",
- *     SK: "7d9afde6683ecc2d1f55e34e1b95de9d4042dfd4e8cda7fdf3f0f7e02fef8f9a",
- *     publicKey: "d58f39dc4bcfe4e8ef022f34e8b6f4f6ddc9c4acee30c0d58f126aa5db3f61b0",
- *     fingerprint: "05294b9aa81d0fd0ca12a4b585f531d8ef1f53f8ea3d0200a0df3f9c44a7d8b1",
- *     lastUsed: new Date(),
- *     verified: false,
- * };
- * ```
+ * @ignore
  */
-export interface ISession extends ISessionSQL {
+export interface Devices {
+    /** Deletes one of the account's devices (except the currently active one). */
+    delete: (deviceID: string) => Promise<void>;
+    /** Registers the current key material as a new device. */
+    register: () => Promise<Device | null>;
+    /** Fetches one device by ID. */
+    retrieve: (deviceIdentifier: string) => Promise<Device | null>;
 }
 /**
- * IChannel is a chat channel on a server.
+ * Channel is a chat channel on a server.
  *
  * Common fields:
  * - `channelID`
  * - `serverID`
  * - `name`
  */
-export type { IChannel } from "@vex-chat/types";
+export type { Channel } from "@vex-chat/types";
 /**
- * IServer is a single chat server.
+ * Server is a single chat server.
  *
  * Common fields:
  * - `serverID`
  * - `name`
  * - `icon` (optional URL/data)
  */
-export type { IServer } from "@vex-chat/types";
+export type { Server } from "@vex-chat/types";
 /**
- * IFile is an uploaded encrypted file.
- *
- * Common fields:
- * - `fileID`: file identifier
- * - `owner`: owner device/user ID
- * - `nonce`: file encryption nonce (hex)
- *
- * @example
- * ```ts
- * const file: IFile = {
- *     fileID: "bb1c3fd1-4928-48ab-9d09-3ea0972fbd9d",
- *     owner: "9b0f3f46-06ad-4bc4-8adf-4de10e13cb9c",
- *     nonce: "aa6c8d42f3fdd032a1e9fced4be379582d26ce8f69822d64",
- * };
- * ```
+ * @ignore
+ */
+export interface Emojis {
+    /** Uploads a custom emoji to a server. */
+    create: (emoji: Uint8Array, name: string, serverID: string) => Promise<Emoji | null>;
+    /** Fetches one emoji's metadata by ID. */
+    retrieve: (emojiID: string) => Promise<Emoji | null>;
+    /** Lists emojis available on a server. */
+    retrieveList: (serverID: string) => Promise<Emoji[]>;
+}
+/**
+ * Progress payload emitted by the `fileProgress` event.
  */
-export interface IFile extends IFileSQL {
+export interface FileProgress {
+    /** Whether this progress event is for upload or download. */
+    direction: "download" | "upload";
+    /** Bytes transferred so far. */
+    loaded: number;
+    /** Integer percentage from `0` to `100`. */
+    progress: number;
+    /** Correlation token (file ID, nonce, or label depending on operation). */
+    token: string;
+    /** Total expected bytes when available, otherwise `0`. */
+    total: number;
 }
 /**
- * IFileRes is a server response to a file retrieval request.
+ * FileRes is a server response to a file retrieval request.
  *
  * Structure:
- * - `details`: metadata (`IFile`)
+ * - `details`: metadata (`VexFile`)
  * - `data`: decrypted binary bytes
  *
  * @example
  * ```ts
- * const response: IFileRes = {
+ * const response: FileRes = {
  *     details: {
  *         fileID: "bb1c3fd1-4928-48ab-9d09-3ea0972fbd9d",
  *         owner: "9b0f3f46-06ad-4bc4-8adf-4de10e13cb9c",
@@ -166,313 +130,218 @@ export interface IFile extends IFileSQL {
  * };
  * ```
  */
-export interface IFileRes extends IFileResponse {
+export type FileRes = FileResponse;
+/**
+ * @ignore
+ */
+export interface Files {
+    /** Uploads and encrypts a file. */
+    create: (file: Uint8Array) => Promise<[FileSQL, string]>;
+    /** Downloads and decrypts a file using a file ID and key. */
+    retrieve: (fileID: string, key: string) => Promise<FileResponse | null>;
+}
+/**
+ * @ignore
+ */
+export interface Invites {
+    /** Creates an invite for a server and duration. */
+    create: (serverID: string, duration: string) => Promise<Invite>;
+    /** Redeems an invite and returns the created permission grant. */
+    redeem: (inviteID: string) => Promise<Permission>;
+    /** Lists active invites for a server. */
+    retrieve: (serverID: string) => Promise<Invite[]>;
+}
+/**
+ * Keys are a pair of ed25519 public and private keys,
+ * encoded as hex strings.
+ */
+export interface Keys {
+    /** Secret Ed25519 key as hex. Store securely. */
+    private: string;
+    /** Public Ed25519 key as hex. */
+    public: string;
 }
 /**
  * @ignore
  */
-export interface IMe {
-    /** Returns the currently authenticated user profile. */
-    user: () => IUser;
+export interface Me {
     /** Returns metadata for the currently authenticated device. */
-    device: () => IDevice;
+    device: () => Device;
     /** Uploads and sets a new avatar image for the current user. */
     setAvatar: (avatar: Uint8Array) => Promise<void>;
+    /** Returns the currently authenticated user profile. */
+    user: () => User;
 }
 /**
- * @ignore
+ * Message is a chat message.
  */
-export interface IUsers {
-    /**
-     * Looks up a user by user ID, username, or signing key.
-     */
-    retrieve: (userID: string) => Promise<[IUser | null, AxiosError | null]>;
-    /** Returns users with whom the current device has active sessions. */
-    familiars: () => Promise<IUser[]>;
+export interface Message {
+    /** User ID of the original author. */
+    authorID: string;
+    /** Whether payload decryption succeeded. */
+    decrypted: boolean;
+    /** Whether this message was received or sent by the current client. */
+    direction: "incoming" | "outgoing";
+    /** `true` when this message was forwarded to another owned device. */
+    forward: boolean;
+    /** Channel ID for group messages; `null` for direct messages. */
+    group: null | string;
+    /** Globally unique message identifier. */
+    mailID: string;
+    /** Plaintext message content (or empty string when decryption failed). */
+    message: string;
+    /** Hex-encoded nonce used for message encryption. */
+    nonce: string;
+    /** User ID of the intended reader. */
+    readerID: string;
+    /** Recipient device ID. */
+    recipient: string;
+    /** Sender device ID. */
+    sender: string;
+    /** Time the message was created/received. */
+    timestamp: string;
+}
+/**
+ * Event signatures emitted by {@link Client}.
+ *
+ * Used as the type parameter for {@link Client.on}, {@link Client.off},
+ * and {@link Client.once}.
+ */
+export interface ClientEvents {
+    /** The client has been shut down (via {@link Client.close}). */
+    closed: () => void;
+    /** WebSocket authorized by the server; pre-auth setup begins. */
+    connected: () => void;
+    /** Mail decryption pass is in progress. */
+    decryptingMail: () => void;
+    /** WebSocket connection lost. */
+    disconnect: () => void;
+    /** Progress update for a file upload or download. */
+    fileProgress: (progress: FileProgress) => void;
+    /** A direct or group message was sent or received. */
+    message: (message: Message) => void;
+    /** A permission grant was created or modified. */
+    permission: (permission: Permission) => void;
+    /** Post-auth setup complete — safe to call messaging/user APIs. */
+    ready: () => void;
+    /** A new encryption session was established with a peer device. */
+    session: (session: Session, user: User) => void;
 }
 /**
  * @ignore
  */
-export interface IMessages {
-    /** Sends an encrypted direct message to one user. */
-    send: (userID: string, message: string) => Promise<void>;
+export interface Messages {
+    /** Deletes local history for a user/channel. */
+    delete: (userOrChannelID: string) => Promise<void>;
     /** Sends an encrypted message to all members of a channel. */
     group: (channelID: string, message: string) => Promise<void>;
-    /** Returns local direct-message history with one user. */
-    retrieve: (userID: string) => Promise<IMessage[]>;
-    /** Returns local group-message history for one channel. */
-    retrieveGroup: (channelID: string) => Promise<IMessage[]>;
-    /** Deletes local history for a user/channel, optionally older than a duration. */
-    delete: (userOrChannelID: string, duration?: string) => Promise<void>;
     /** Deletes all locally stored message history. */
     purge: () => Promise<void>;
+    /** Returns local direct-message history with one user. */
+    retrieve: (userID: string) => Promise<Message[]>;
+    /** Returns local group-message history for one channel. */
+    retrieveGroup: (channelID: string) => Promise<Message[]>;
+    /** Sends an encrypted direct message to one user. */
+    send: (userID: string, message: string) => Promise<void>;
 }
 /**
  * @ignore
  */
-export interface IServers {
-    /** Lists servers available to the authenticated user. */
-    retrieve: () => Promise<IServer[]>;
-    /** Gets one server by ID. */
-    retrieveByID: (serverID: string) => Promise<IServer | null>;
-    /** Creates a server. */
-    create: (name: string) => Promise<IServer>;
-    /** Deletes a server. */
-    delete: (serverID: string) => Promise<void>;
-    /** Leaves a server by removing the user's permission entry. */
-    leave: (serverID: string) => Promise<void>;
-}
-/**
- * @ignore
- */
-export interface IModeration {
+export interface Moderation {
+    /** Returns all permission entries for a server. */
+    fetchPermissionList: (serverID: string) => Promise<Permission[]>;
     /** Removes a user from a server by revoking their server permission(s). */
     kick: (userID: string, serverID: string) => Promise<void>;
-    /** Returns all permission entries for a server. */
-    fetchPermissionList: (serverID: string) => Promise<IPermission[]>;
 }
 /**
  * @ignore
  */
-export interface IPermissions {
-    /** Lists permissions granted to the authenticated user. */
-    retrieve: () => Promise<IPermission[]>;
+export interface Permissions {
     /** Deletes one permission grant. */
     delete: (permissionID: string) => Promise<void>;
+    /** Lists permissions granted to the authenticated user. */
+    retrieve: () => Promise<Permission[]>;
 }
 /**
  * @ignore
  */
-export interface IInvites {
-    /** Redeems an invite and returns the created permission grant. */
-    redeem: (inviteID: string) => Promise<IPermission>;
-    /** Creates an invite for a server and duration. */
-    create: (serverID: string, duration: string) => Promise<IInvite>;
-    /** Lists active invites for a server. */
-    retrieve: (serverID: string) => Promise<IInvite[]>;
+export interface Servers {
+    /** Creates a server. */
+    create: (name: string) => Promise<Server>;
+    /** Deletes a server. */
+    delete: (serverID: string) => Promise<void>;
+    /** Leaves a server by removing the user's permission entry. */
+    leave: (serverID: string) => Promise<void>;
+    /** Lists servers available to the authenticated user. */
+    retrieve: () => Promise<Server[]>;
+    /** Gets one server by ID. */
+    retrieveByID: (serverID: string) => Promise<null | Server>;
 }
 /**
- * @ignore
+ * Session is an end to end encryption session with another peer.
+ *
+ * Key fields include:
+ * - `sessionID`
+ * - `userID`
+ * - `deviceID`
+ * - `mode` (`initiator` or `receiver`)
+ * - `publicKey` and `fingerprint`
+ * - `lastUsed`
+ * - `verified`
+ *
+ * @example
+ * ```ts
+ * const session: Session = {
+ *     sessionID: "f6e4fbd0-7222-4ba8-b799-c227faf5c8de",
+ *     userID: "f34f5e37-616f-4d3a-a437-e7c27c31cb73",
+ *     deviceID: "9b0f3f46-06ad-4bc4-8adf-4de10e13cb9c",
+ *     mode: "initiator",
+ *     SK: "7d9afde6683ecc2d1f55e34e1b95de9d4042dfd4e8cda7fdf3f0f7e02fef8f9a",
+ *     publicKey: "d58f39dc4bcfe4e8ef022f34e8b6f4f6ddc9c4acee30c0d58f126aa5db3f61b0",
+ *     fingerprint: "05294b9aa81d0fd0ca12a4b585f531d8ef1f53f8ea3d0200a0df3f9c44a7d8b1",
+ *     lastUsed: new Date(),
+ *     verified: false,
+ * };
+ * ```
  */
-export interface IChannels {
-    /** Lists channels in a server. */
-    retrieve: (serverID: string) => Promise<IChannel[]>;
-    /** Gets one channel by ID. */
-    retrieveByID: (channelID: string) => Promise<IChannel | null>;
-    /** Creates a channel in a server. */
-    create: (name: string, serverID: string) => Promise<IChannel>;
-    /** Deletes a channel. */
-    delete: (channelID: string) => Promise<void>;
-    /** Lists users currently visible in a channel. */
-    userList: (channelID: string) => Promise<IUser[]>;
-}
+export type Session = SessionSQL;
 /**
  * @ignore
  */
-export interface ISessions {
-    /** Returns all locally known sessions. */
-    retrieve: () => Promise<ISessionSQL[]>;
-    /** Builds a human-readable verification phrase from a session fingerprint. */
-    verify: (session: ISessionSQL) => string;
+export interface Sessions {
     /** Marks one session as verification-confirmed. */
     markVerified: (fingerprint: string) => Promise<void>;
+    /** Returns all locally known sessions. */
+    retrieve: () => Promise<SessionSQL[]>;
+    /** Builds a human-readable verification phrase from a session fingerprint. */
+    verify: (session: SessionSQL) => string;
 }
 /**
- * @ignore
- */
-export interface IDevices {
-    /** Fetches one device by ID. */
-    retrieve: (deviceIdentifier: string) => Promise<IDevice | null>;
-    /** Registers the current key material as a new device. */
-    register: () => Promise<IDevice | null>;
-    /** Deletes one of the account's devices (except the currently active one). */
-    delete: (deviceID: string) => Promise<void>;
-}
-/**
- * @ignore
+ * User is a single user on the vex platform.
+ *
+ * This is intentionally a censored user shape for client use, containing:
+ * - `userID`
+ * - `username`
+ * - `lastSeen`
  */
-export interface IFiles {
-    /** Uploads and encrypts a file. */
-    create: (file: Uint8Array) => Promise<[IFileSQL, string]>;
-    /** Downloads and decrypts a file using a file ID and key. */
-    retrieve: (fileID: string, key: string) => Promise<IFileResponse | null>;
+export interface User {
+    /** Last-seen timestamp (ISO 8601 string). */
+    lastSeen: string;
+    /** User identifier. */
+    userID: string;
+    /** Public username. */
+    username: string;
 }
 /**
  * @ignore
  */
-export interface IEmojis {
-    /** Uploads a custom emoji to a server. */
-    create: (emoji: Uint8Array, name: string, serverID: string) => Promise<IEmoji | null>;
-    /** Lists emojis available on a server. */
-    retrieveList: (serverID: string) => Promise<IEmoji[]>;
-    /** Fetches one emoji's metadata by ID. */
-    retrieve: (emojiID: string) => Promise<IEmoji | null>;
-}
-/**
- * Progress payload emitted by the `fileProgress` event.
- */
-export interface IFileProgress {
-    /** Correlation token (file ID, nonce, or label depending on operation). */
-    token: string;
-    /** Whether this progress event is for upload or download. */
-    direction: "upload" | "download";
-    /** Integer percentage from `0` to `100`. */
-    progress: number;
-    /** Bytes transferred so far. */
-    loaded: number;
-    /** Total expected bytes when available, otherwise `0`. */
-    total: number;
-}
-/**
- * IClientOptions are the options you can pass into the client.
- */
-export interface IClientOptions {
-    /** Logging level for client runtime logs. */
-    logLevel?: "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
-    /** API host without protocol. Defaults to `api.vex.wtf`. */
-    host?: string;
-    /** Folder path where the sqlite file is created. */
-    dbFolder?: string;
-    /** Use sqlite in-memory mode (`:memory:`) instead of a file. */
-    inMemoryDb?: boolean;
-    /** Logging level for storage/database logs. */
-    dbLogLevel?: "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
-    /** Use `http/ws` instead of `https/wss`. Intended for local/dev environments. */
-    unsafeHttp?: boolean;
-    /** Whether local message history should be persisted by default storage. */
-    saveHistory?: boolean;
-    /** Platform-specific adapters (WebSocket + Logger). When omitted, defaults to Node.js ws. */
-    adapters?: IClientAdapters;
-    /** Platform label for device registration (e.g. "ios", "macos", "linux"). */
-    deviceName?: string;
-}
-export declare interface Client {
-    /**
-     * This is emitted for file progress events.
-     *
-     * Example:
-     *
-     * ```ts
-     *   client.on("ready", () => {
-     *       await client.register()
-     *   });
-     * ```
-     *
-     * @event
-     */
-    on(event: "fileProgress", callback: (progress: IFileProgress) => void): this;
-    /**
-     * This is emitted whenever the keyring is done initializing after an init()
-     * call. You must wait to login or register until after this event.
-     *
-     * Example:
-     *
-     * ```ts
-     *   client.on("ready", () => {
-     *       await client.register()
-     *   });
-     * ```
-     *
-     * @event
-     */
-    on(event: "ready", callback: () => void): this;
-    /**
-     * Emitted before the first inbox fetch/decrypt cycle after connect.
-     *
-     * Use this to show temporary loading UI while historical messages are
-     * decrypted from server payloads.
-     *
-     * @event
-     */
-    on(event: "decryptingMail", callback: () => void): this;
-    /**
-     * This is emitted when you are connected to the chat.
-     *
-     * Example:
-     *
-     * ```ts
-     *   client.on("connected", (user) => {
-     *       // do something
-     *   });
-     * ```
-     *
-     * @event
-     */
-    on(event: "connected", callback: () => void): this;
-    /**
-     * This is emitted for every sent and received message.
-     *
-     * Example:
-     *
-     * ```ts
-     *
-     *   client.on("message", (msg: IMessage) => {
-     *       console.log(message);
-     *   });
-     * ```
-     * @event
-     */
-    on(event: "message", callback: (message: IMessage) => void): this;
-    /**
-     * This is emitted when the user is granted a new permission.
-     *
-     * Example:
-     *
-     * ```ts
-     *
-     *   client.on("permission", (perm: IPermission) => {
-     *       console.log(perm);
-     *   });
-     * ```
-     * @event
-     */
-    on(event: "permission", callback: (permission: IPermission) => void): this;
-    /**
-     * This is emitted for a new encryption session being created with
-     * a specific user.
-     *
-     * Example:
-     *
-     * ```ts
-     *
-     *   client.on("session", (session: ISession, user: IUser) => {
-     *       console.log(session);
-     *       console.log(user);
-     *   });
-     * ```
-     * @event
-     */
-    on(event: "session", callback: (session: ISession, user: IUser) => void): this;
-    /**
-     * This is emitted whenever the connection is closed. You must discard the client
-     * and connect again with a fresh one.
-     *
-     * Example:
-     * ```ts
-     *
-     *   client.on("disconnect", () => {
-     *     // do something
-     *   });
-     * ```
-     * @event
-     */
-    on(event: "disconnect", callback: () => void): this;
+export interface Users {
+    /** Returns users with whom the current device has active sessions. */
+    familiars: () => Promise<User[]>;
     /**
-     * This is emitted whenever the close() event is called and completed successfully.
-     * Note this is not fired for an unintentional disconnect, see the disconnect event.
-     *
-     * Example:
-     *
-     * ```ts
-     *
-     *   client.on("closed", () => {
-     *       process.exit(0);
-     *   });
-     * ```
-     *
-     * @event
+     * Looks up a user by user ID, username, or signing key.
      */
-    on(event: "closed", callback: () => void): this;
+    retrieve: (userID: string) => Promise<[null | User, AxiosError | null]>;
 }
 /**
  * Client provides an interface for you to use a vex chat server and
@@ -486,23 +355,16 @@ export declare interface Client {
  *     // generate a secret key to use, save this somewhere permanent
  *     const privateKey = Client.generateSecretKey();
  *
- *     const client = new Client(privateKey);
+ *     const client = await Client.create(privateKey);
  *
- *     // the ready event is emitted when init() is finished.
- *     // you must wait until this event fires to perform
- *     // registration or login.
- *     client.on("ready", async () => {
- *         // you must register once before you can log in
- *         await client.register(Client.randomUsername());
- *         await client.login();
- *     })
+ *     // you must register once before you can log in
+ *     await client.register(Client.randomUsername());
+ *     await client.login();
  *
- *     // The authed event fires when login() successfully completes
- *     // and the server indicates you are authorized. You must wait to
- *     // perform any operations besides register() and login() until
- *     // this occurs.
- *     client.on("authed", async () => {
- *         const me = await client.users.me();
+ *     // The ready event fires after connect() finishes post-auth setup.
+ *     // Wait for it before performing messaging or user operations.
+ *     client.on("ready", async () => {
+ *         const me = client.me.user();
  *
  *         // send a message
  *         await client.messages.send(me.userID, "Hello world!");
@@ -512,22 +374,30 @@ export declare interface Client {
  *     client.on("message", (message) => {
  *         console.log("message:", message);
  *     })
- *
- *     // you must call init() to initialize the keyring and
- *     // start the client.
- *     client.init();
  * }
  *
  * main();
  * ```
  */
-export declare class Client extends EventEmitter {
-    /**
-     * Encrypts a secret key with a password.
-     *
-     * Pass-through utility from `@vex-chat/crypto`.
-     */
-    static encryptKeyData: (password: string, keyToSave: string, iterationOverride?: number) => Uint8Array;
+/**
+ * VexFile is an uploaded encrypted file.
+ *
+ * Common fields:
+ * - `fileID`: file identifier
+ * - `owner`: owner device/user ID
+ * - `nonce`: file encryption nonce (hex)
+ *
+ * @example
+ * ```ts
+ * const file: VexFile = {
+ *     fileID: "bb1c3fd1-4928-48ab-9d09-3ea0972fbd9d",
+ *     owner: "9b0f3f46-06ad-4bc4-8adf-4de10e13cb9c",
+ *     nonce: "aa6c8d42f3fdd032a1e9fced4be379582d26ce8f69822d64",
+ * };
+ * ```
+ */
+export type VexFile = FileSQL;
+export declare class Client {
     /**
      * Decrypts a secret key from encrypted data produced by encryptKeyData().
      *
@@ -535,42 +405,25 @@ export declare class Client extends EventEmitter {
      */
     static decryptKeyData: (keyData: Uint8Array, password: string) => string;
     /**
-     * Creates and initializes a client in one step.
-     *
-     * @param privateKey Optional hex secret key. When omitted, a fresh key is generated.
-     * @param options Runtime options.
-     * @param storage Optional custom storage backend implementing `IStorage`.
-     *
-     * @example
-     * ```ts
-     * const client = await Client.create(privateKey, { host: "api.vex.wtf" });
-     * ```
-     */
-    static create: (privateKey?: string, options?: IClientOptions, storage?: IStorage) => Promise<Client>;
-    /**
-     * Generates an ed25519 secret key as a hex string.
+     * Encrypts a secret key with a password.
      *
-     * @returns - A secret key to use for the client. Save it permanently somewhere safe.
+     * Pass-through utility from `@vex-chat/crypto`.
      */
-    static generateSecretKey(): string;
+    static encryptKeyData: (password: string, keyToSave: string, iterationOverride?: number) => Uint8Array;
+    private static readonly NOT_FOUND_TTL;
     /**
-     * Generates a random username using bip39.
-     *
-     * @returns - The username.
+     * Browser-safe NODE_ENV accessor.
+     * Uses indirect lookup so the bare `process` global never appears in
+     * source that the platform-guard plugin scans.
      */
-    static randomUsername(): string;
-    private static getMnemonic;
-    private static deserializeExtra;
     /**
-     * User operations.
-     *
-     * @example
-     * ```ts
-     * const [user] = await client.users.retrieve("alice");
-     * const familiarUsers = await client.users.familiars();
-     * ```
+     * Channel operations.
+     */
+    channels: Channels;
+    /**
+     * Device management methods.
      */
-    users: IUsers;
+    devices: Devices;
     /**
      * Emoji operations.
      *
@@ -580,29 +433,26 @@ export declare class Client extends EventEmitter {
      * const list = await client.emoji.retrieveList(serverID);
      * ```
      */
-    emoji: IEmojis;
-    /**
-     * Helpers for information/actions related to the currently authenticated account.
-     */
-    me: IMe;
-    /**
-     * Device management methods.
-     */
-    devices: IDevices;
+    emoji: Emojis;
     /** File upload/download methods. */
-    files: IFiles;
+    files: Files;
     /**
-     * Permission-management methods for the current user.
+     * This is true if the client has ever been initialized. You can only initialize
+     * a client once.
      */
-    permissions: IPermissions;
+    hasInit: boolean;
     /**
-     * Server moderation helper methods.
+     * This is true if the client has ever logged in before. You can only login a client once.
      */
-    moderation: IModeration;
+    hasLoggedIn: boolean;
     /**
      * Invite-management methods.
      */
-    invites: IInvites;
+    invites: Invites;
+    /**
+     * Helpers for information/actions related to the currently authenticated account.
+     */
+    me: Me;
     /**
      * Message operations (direct and group).
      *
@@ -613,11 +463,16 @@ export declare class Client extends EventEmitter {
      * const dmHistory = await client.messages.retrieve(userID);
      * ```
      */
-    messages: IMessages;
+    messages: Messages;
     /**
-     * Encryption-session helpers.
+     * Server moderation helper methods.
+     */
+    moderation: Moderation;
+    /**
+     * Permission-management methods for the current user.
      */
-    sessions: ISessions;
+    permissions: Permissions;
+    sending: Map<string, Device>;
     /**
      * Server operations.
      *
@@ -627,79 +482,130 @@ export declare class Client extends EventEmitter {
      * const created = await client.servers.create("Team Space");
      * ```
      */
-    servers: IServers;
-    /**
-     * Channel operations.
-     */
-    channels: IChannels;
+    servers: Servers;
     /**
-     * This is true if the client has ever been initialized. You can only initialize
-     * a client once.
+     * Encryption-session helpers.
      */
-    hasInit: boolean;
+    sessions: Sessions;
     /**
-     * This is true if the client has ever logged in before. You can only login a client once.
+     * User operations.
+     *
+     * @example
+     * ```ts
+     * const [user] = await client.users.retrieve("alice");
+     * const familiarUsers = await client.users.familiars();
+     * ```
      */
-    hasLoggedIn: boolean;
-    sending: Record<string, IDevice>;
-    private database;
-    private dbPath;
-    private conn;
-    private host;
-    private adapters;
-    private firstMailFetch;
-    private signKeys;
-    private idKeys;
-    private xKeyRing?;
-    private user?;
+    users: Users;
+    private readonly database;
+    private readonly dbPath;
     private device?;
-    private userRecords;
     private deviceRecords;
-    private sessionRecords;
-    private isAlive;
-    private reading;
+    private readonly emitter;
     private fetchingMail;
-    private ax;
-    private log;
-    private pingInterval;
-    private mailInterval?;
+    private firstMailFetch;
+    private readonly forwarded;
+    private readonly host;
+    private readonly http;
+    private readonly idKeys;
+    private isAlive;
+    private readonly mailInterval?;
     private manuallyClosing;
+    /** Negative cache for user lookups that returned 404. TTL = 30 minutes. */
+    private readonly notFoundUsers;
+    private readonly options?;
+    private pingInterval;
+    private readonly prefixes;
+    private reading;
+    private readonly seenMailIDs;
+    private sessionRecords;
+    private readonly signKeys;
+    private socket;
     private token;
-    private forwarded;
-    private prefixes;
-    private options?;
+    private user?;
+    private userRecords;
+    private xKeyRing?;
     private constructor();
     /**
-     * Returns the current HTTP API origin with protocol.
+     * Creates and initializes a client in one step.
+     *
+     * @param privateKey - Hex secret key. When omitted, a fresh key is generated.
+     * @param options - Runtime options.
+     * @param storage - Custom storage backend implementing {@link Storage}.
      *
      * @example
      * ```ts
-     * console.log(client.getHost()); // "https://api.vex.wtf"
+     * const client = await Client.create(privateKey, { host: "api.vex.wtf" });
      * ```
      */
-    getHost(): string;
+    static create: (privateKey?: string, options?: ClientOptions, storage?: Storage) => Promise<Client>;
     /**
-     * Manually closes the client. Emits the closed event on successful shutdown.
+     * Generates an ed25519 secret key as a hex string.
+     *
+     * @returns A secret key to use for the client. Save it permanently somewhere safe.
+     */
+    static generateSecretKey(): string;
+    /**
+     * Generates a random username using bip39.
+     *
+     * @returns The username.
+     */
+    static randomUsername(): string;
+    private static deserializeExtra;
+    private static getMnemonic;
+    /**
+     * Browser-safe NODE_ENV accessor.
+     * Uses indirect lookup so the bare `process` global never appears in
+     * source that the platform-guard plugin scans.
+     */
+    private static getNodeEnv;
+    /**
+     * Closes the client — disconnects the WebSocket, shuts down storage,
+     * and emits `closed` unless `muteEvent` is `true`.
+     *
+     * @param muteEvent - When `true`, suppresses the `closed` event.
      */
     close(muteEvent?: boolean): Promise<void>;
+    /**
+     * Connects your device to the chat. You must have a valid Bearer token.
+     * You can check whoami() to see before calling connect().
+     */
+    connect(): Promise<void>;
+    /**
+     * Delete all local data — message history, encryption sessions, and prekeys.
+     * Closes the client afterward. Credentials (keychain) must be cleared by the consumer.
+     */
+    deleteAllData(): Promise<void>;
+    /**
+     * Returns the current HTTP API origin with protocol.
+     *
+     * @example
+     * ```ts
+     * console.log(client.getHost()); // "https://api.vex.wtf"
+     * ```
+     */
+    getHost(): string;
     /**
      * Gets the hex string representations of the public and private keys.
      */
-    getKeys(): IKeys;
+    getKeys(): Keys;
     /**
      * Authenticates with username/password and stores the Bearer auth token.
      *
-     * @param username Account username.
-     * @param password Account password.
-     * @returns `null` on success, or the thrown error object on failure.
+     * @param username - Account username.
+     * @param password - Account password.
+     * @returns `{ ok: true }` on success, `{ ok: false, error }` on failure.
      *
      * @example
      * ```ts
-     * const err = await client.login("alice", "correct horse battery staple");
-     * if (err) console.error(err);
+     * const result = await client.login("alice", "correct horse battery staple");
+     * if (!result.ok) console.error(result.error);
      * ```
      */
-    login(username: string, password: string): Promise<Error | null>;
+    login(username: string, password: string): Promise<{
+        error?: string;
+        ok: boolean;
+    }>;
     /**
      * Authenticates using the device's Ed25519 signing key.
      * No password needed — proves possession of the private key via
@@ -709,6 +615,34 @@ export declare class Client extends EventEmitter {
      * but no valid session.
      */
     loginWithDeviceKey(deviceID?: string): Promise<Error | null>;
+    /**
+     * Logs out the current authenticated session from the server.
+     */
+    logout(): Promise<void>;
+    /** Removes an event listener. See {@link ClientEvents} for available events. */
+    off<E extends keyof ClientEvents>(event: E, fn?: ClientEvents[E], context?: unknown): this;
+    /** Subscribes to an event. See {@link ClientEvents} for available events. */
+    on<E extends keyof ClientEvents>(event: E, fn: ClientEvents[E], context?: unknown): this;
+    /** Subscribes to an event for a single firing, then auto-removes. */
+    once<E extends keyof ClientEvents>(event: E, fn: ClientEvents[E], context?: unknown): this;
+    /**
+     * Registers a new account on the server.
+     *
+     * @param username - The username to register. Must be unique.
+     * @param password - Account password.
+     * @returns `[user, null]` on success, `[null, error]` on failure.
+     *
+     * @example
+     * ```ts
+     * const [user, err] = await client.register("MyUsername", "hunter2");
+     * ```
+     */
+    register(username: string, password: string): Promise<[null | User, Error | null]>;
+    removeAllListeners(event?: keyof ClientEvents): this;
+    /**
+     * Returns a compact `<username><deviceID>` debug label.
+     */
+    toString(): string;
     /**
      * Returns details about the currently authenticated session.
      *
@@ -721,110 +655,89 @@ export declare class Client extends EventEmitter {
      * ```
      */
     whoami(): Promise<{
-        user: IUser;
         exp: number;
         token: string;
+        user: User;
     }>;
-    /**
-     * Logs out the current authenticated session from the server.
-     */
-    logout(): Promise<void>;
-    /**
-     * Connects your device to the chat. You must have a valid Bearer token.
-     * You can check whoami() to see before calling connect().
-     */
-    connect(): Promise<void>;
-    /**
-     * Registers a new account on the server.
-     * @param username The username to register. Must be unique.
-     *
-     * @returns The error, or the user object.
-     *
-     * @example [user, err] = await client.register("MyUsername");
-     */
-    register(username: string, password: string): Promise<[IUser | null, Error | null]>;
-    /**
-     * Returns a compact `<username><deviceID>` debug label.
-     */
-    toString(): string;
-    private redeemInvite;
-    private retrieveInvites;
+    private censorPreKey;
+    private createChannel;
+    private createFile;
     private createInvite;
-    private retrieveEmojiList;
-    private retrieveEmojiByID;
-    private leaveServer;
-    private kickUser;
-    private uploadEmoji;
-    private retrieveOrCreateDevice;
-    private registerDevice;
-    private getToken;
-    private uploadAvatar;
+    private createPreKey;
+    private createServer;
+    private createSession;
+    private deleteChannel;
+    private deleteDevice;
+    private deleteHistory;
+    private deletePermission;
+    private deleteServer;
     /**
      * Gets a list of permissions for a server.
      *
-     * @returns - The list of IPermissions objects.
+     * @returns The list of Permission objects.
      */
     private fetchPermissionList;
+    private fetchUser;
+    private forward;
+    private getChannelByID;
+    private getChannelList;
+    private getDevice;
+    private getDeviceByID;
+    private getFamiliars;
+    private getGroupHistory;
+    private getMail;
+    private getMessageHistory;
+    private getMultiUserDeviceList;
+    private getOTKCount;
     /**
      * Gets all permissions for the logged in user.
      *
-     * @returns - The list of IPermissions objects.
+     * @returns The list of Permission objects.
      */
     private getPermissions;
-    private deletePermission;
-    private retrieveFile;
-    private deleteServer;
+    private getServerByID;
+    private getServerList;
+    private getSessionByPubkey;
+    private getSessionList;
+    private getToken;
+    private getUser;
+    private getUserDeviceList;
+    private getUserList;
+    private handleNotify;
     /**
      * Initializes the keyring. This must be called before anything else.
      */
     private init;
-    private deleteChannel;
-    private createFile;
-    private getUserList;
+    private initSocket;
+    private kickUser;
+    private leaveServer;
     private markSessionVerified;
-    private getGroupHistory;
-    private deleteHistory;
+    private negotiateOTK;
+    private newEphemeralKeys;
+    private ping;
+    private pong;
+    private populateKeyRing;
+    private postAuth;
     private purgeHistory;
-    private getMessageHistory;
-    private sendMessage;
+    private readMail;
+    private redeemInvite;
+    private registerDevice;
+    private respond;
+    private retrieveEmojiByID;
+    private retrieveEmojiList;
+    private retrieveFile;
+    private retrieveInvites;
+    private retrieveKeyBundle;
+    private retrieveOrCreateDevice;
+    private send;
     private sendGroupMessage;
-    private createServer;
-    private forward;
     private sendMail;
-    private getSessionList;
-    private getServerList;
-    private createChannel;
-    private getDeviceByID;
-    private deleteDevice;
-    private getMultiUserDeviceList;
-    private getUserDeviceList;
-    private getServerByID;
-    private getChannelByID;
-    private getChannelList;
-    private getUser;
-    private getDevice;
-    private setUser;
-    private retrieveUserDBEntry;
-    private getFamiliars;
-    private createSession;
+    private sendMessage;
     private sendReceipt;
-    private getSessionByPubkey;
-    private readMail;
-    private newEphemeralKeys;
-    private createPreKey;
-    private handleNotify;
-    private populateKeyRing;
-    private initSocket;
     private setAlive;
-    private postAuth;
-    private getMail;
-    private send;
-    private retrieveKeyBundle;
-    private getOTKCount;
+    private setUser;
     private submitOTK;
-    private negotiateOTK;
-    private respond;
-    private pong;
-    private ping;
-    private censorPreKey;
+    private uploadAvatar;
+    private uploadEmoji;
 }
+//# sourceMappingURL=Client.d.ts.map