@diaryx/wasm 0.11.0-dev.449d9b2

package/diaryx_wasm.d.ts

@@ -0,0 +1,891 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Callbacks for JsAsyncFileSystem operations.
+ *
+ * All callbacks should return Promises. If a callback is not provided,
+ * the corresponding operation will fail with an error.
+ */
+export interface JsFileSystemCallbacks {
+    /**
+     * Read a file's content as a string.
+     * @param path - The file path to read
+     * @returns Promise resolving to the file content
+     */
+    readToString?: (path: string) => Promise<string>;
+
+    /**
+     * Write content to a file, creating or overwriting it.
+     * @param path - The file path to write
+     * @param content - The content to write
+     */
+    writeFile?: (path: string, content: string) => Promise<void>;
+
+    /**
+     * Create a new file, failing if it already exists.
+     * @param path - The file path to create
+     * @param content - The initial content
+     */
+    createNew?: (path: string, content: string) => Promise<void>;
+
+    /**
+     * Delete a file.
+     * @param path - The file path to delete
+     */
+    deleteFile?: (path: string) => Promise<void>;
+
+    /**
+     * Check if a path exists.
+     * @param path - The path to check
+     * @returns Promise resolving to true if the path exists
+     */
+    exists?: (path: string) => Promise<boolean>;
+
+    /**
+     * Check if a path is a directory.
+     * @param path - The path to check
+     * @returns Promise resolving to true if the path is a directory
+     */
+    isDir?: (path: string) => Promise<boolean>;
+
+    /**
+     * List all files in a directory (not recursive).
+     * @param dir - The directory path
+     * @returns Promise resolving to array of file paths
+     */
+    listFiles?: (dir: string) => Promise<string[]>;
+
+    /**
+     * List markdown files in a directory (not recursive).
+     * @param dir - The directory path
+     * @returns Promise resolving to array of .md file paths
+     */
+    listMdFiles?: (dir: string) => Promise<string[]>;
+
+    /**
+     * Create a directory and all parent directories.
+     * @param path - The directory path to create
+     */
+    createDirAll?: (path: string) => Promise<void>;
+
+    /**
+     * Move/rename a file.
+     * @param from - The source path
+     * @param to - The destination path
+     */
+    moveFile?: (from: string, to: string) => Promise<void>;
+
+    /**
+     * Read binary file content.
+     * @param path - The file path to read
+     * @returns Promise resolving to file content as Uint8Array
+     */
+    readBinary?: (path: string) => Promise<Uint8Array>;
+
+    /**
+     * Write binary content to a file.
+     * @param path - The file path to write
+     * @param data - The binary content as Uint8Array
+     */
+    writeBinary?: (path: string, data: Uint8Array) => Promise<void>;
+}
+
+
+
+/**
+ * Unified async backend with native storage.
+ *
+ * This is the main entry point for all workspace operations in WASM.
+ * It wraps either OPFS or IndexedDB storage and provides a complete
+ * async API for workspace, entry, search, and validation operations.
+ *
+ * ## Usage
+ *
+ * All operations go through `execute()` or `executeJs()`:
+ *
+ * ```javascript
+ * const backend = await DiaryxBackend.createOpfs();
+ * const response = await backend.executeJs({
+ *   type: 'GetEntry',
+ *   params: { path: 'workspace/notes.md' }
+ * });
+ * ```
+ */
+export class DiaryxBackend {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create backend with specific storage type.
+     */
+    static create(storage_type: string): Promise<DiaryxBackend>;
+    /**
+     * Create a new DiaryxBackend from a user-selected directory handle.
+     *
+     * This uses the File System Access API to read/write files directly
+     * on the user's filesystem. The handle must be obtained from
+     * `window.showDirectoryPicker()` in JavaScript.
+     *
+     * ## Browser Support
+     * - Chrome/Edge: ✅ Supported
+     * - Firefox: ❌ Not supported
+     * - Safari: ❌ Not supported
+     *
+     * ## Example
+     * ```javascript
+     * // User must trigger this via a gesture (click/keypress)
+     * const dirHandle = await window.showDirectoryPicker();
+     * const backend = await DiaryxBackend.createFromDirectoryHandle(dirHandle);
+     * ```
+     */
+    static createFromDirectoryHandle(handle: FileSystemDirectoryHandle): DiaryxBackend;
+    /**
+     * Create a new DiaryxBackend with in-memory storage.
+     *
+     * This is used for guest mode in share sessions. Files are stored
+     * only in memory and are cleared when the session ends.
+     *
+     * ## Use Cases
+     * - Guest mode in share sessions (web)
+     * - Testing
+     *
+     * ## Example
+     * ```javascript
+     * const backend = DiaryxBackend.createInMemory();
+     * // Files are stored in memory only
+     * ```
+     */
+    static createInMemory(): DiaryxBackend;
+    /**
+     * Create a new DiaryxBackend with IndexedDB storage.
+     *
+     * This attempts to use persistent SQLite-based CRDT storage (via sql.js).
+     * If SQLite storage is not available, falls back to in-memory CRDT storage.
+     */
+    static createIndexedDb(): Promise<DiaryxBackend>;
+    /**
+     * Create a new DiaryxBackend with OPFS storage.
+     *
+     * This attempts to use persistent SQLite-based CRDT storage (via sql.js).
+     * If SQLite storage is not available (JS bridge not initialized), falls back
+     * to in-memory CRDT storage.
+     *
+     * For persistent CRDT storage, call `initializeSqliteStorage()` in JavaScript
+     * before creating the backend:
+     *
+     * ```javascript
+     * import { initializeSqliteStorage } from './lib/storage/sqliteStorageBridge.js';
+     * await initializeSqliteStorage();
+     * const backend = await DiaryxBackend.createOpfs();
+     * ```
+     */
+    static createOpfs(): Promise<DiaryxBackend>;
+    /**
+     * Create a new sync client for the given server and workspace.
+     *
+     * This creates a `WasmSyncClient` that wraps `SyncClient<CallbackTransport>`.
+     * JavaScript manages WebSocket connections while Rust handles all sync logic.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * const client = backend.createSyncClient(
+     *   'wss://sync.example.com/sync',
+     *   'my-workspace-id',
+     *   'auth-token-optional'
+     * );
+     *
+     * // Get URLs and create WebSocket connections
+     * const metaUrl = client.getMetadataUrl();
+     * const bodyUrl = client.getBodyUrl();
+     *
+     * // Create WebSockets and connect them to the client
+     * const metaWs = new WebSocket(metaUrl);
+     * metaWs.binaryType = 'arraybuffer';
+     * metaWs.onopen = () => client.markMetadataConnected();
+     * metaWs.onclose = () => client.markMetadataDisconnected();
+     * metaWs.onmessage = async (e) => {
+     *   const response = await client.injectMetadataMessage(new Uint8Array(e.data));
+     *   if (response) metaWs.send(response);
+     * };
+     * // Similar for body WebSocket...
+     *
+     * // Poll for outgoing messages
+     * setInterval(() => {
+     *   let msg;
+     *   while ((msg = client.pollMetadataOutgoing())) metaWs.send(msg);
+     *   while ((msg = client.pollBodyOutgoing())) bodyWs.send(msg);
+     * }, 50);
+     *
+     * // Start sync
+     * await client.start();
+     * ```
+     */
+    createSyncClient(server_url: string, workspace_id: string, auth_token?: string | null): WasmSyncClient;
+    /**
+     * Emit a filesystem event.
+     *
+     * This is primarily used internally but can be called from JavaScript
+     * to manually trigger events (e.g., for testing or manual sync scenarios).
+     *
+     * The event should be a JSON string matching the FileSystemEvent format.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * backend.emitFileSystemEvent(JSON.stringify({
+     *     type: 'FileCreated',
+     *     path: 'workspace/notes.md',
+     *     frontmatter: { title: 'Notes' }
+     * }));
+     * ```
+     */
+    emitFileSystemEvent(event_json: string): void;
+    /**
+     * Get the number of active event subscriptions.
+     */
+    eventSubscriberCount(): number;
+    /**
+     * Execute a command and return the response as JSON string.
+     *
+     * This is the primary unified API for all operations.
+     *
+     * ## Example
+     * ```javascript
+     * const command = { type: 'GetEntry', params: { path: 'workspace/notes.md' } };
+     * const responseJson = await backend.execute(JSON.stringify(command));
+     * const response = JSON.parse(responseJson);
+     * ```
+     */
+    execute(command_json: string): Promise<string>;
+    /**
+     * Execute a command from a JavaScript object directly.
+     *
+     * This avoids JSON serialization overhead for better performance.
+     */
+    executeJs(command: any): Promise<any>;
+    /**
+     * Get initial body sync step1 message for a document.
+     *
+     * Returns a Uint8Array containing the Y-sync step1 message for
+     * the specified document's body content.
+     *
+     * ## Example
+     * ```javascript
+     * const step1 = backend.getBodySyncStep1("notes/my-note.md");
+     * // Frame it for multiplexed connection and send
+     * ```
+     */
+    getBodySyncStep1(doc_name: string): Uint8Array;
+    /**
+     * Get the current configuration from root index frontmatter.
+     * Config keys are stored as `diaryx_*` properties.
+     */
+    getConfig(): Promise<any>;
+    /**
+     * Get initial workspace sync step1 message.
+     *
+     * Returns a Uint8Array containing the Y-sync step1 message to send
+     * over the WebSocket to initiate workspace metadata sync.
+     *
+     * ## Example
+     * ```javascript
+     * const step1 = backend.getWorkspaceSyncStep1();
+     * ws.send(step1);
+     * ```
+     */
+    getWorkspaceSyncStep1(): Uint8Array;
+    /**
+     * Check if this backend has native sync support.
+     *
+     * For WASM, this always returns false. The new `createSyncClient()` API
+     * provides a unified approach that works across all platforms.
+     */
+    hasNativeSync(): boolean;
+    /**
+     * Check if there are pending outgoing sync messages.
+     */
+    hasOutgoingSyncMessages(): boolean;
+    /**
+     * Inject an incoming body sync message.
+     *
+     * Call this when the WebSocket receives a message for a body document.
+     * The message should already be unframed (doc_name extracted separately).
+     * Returns a response message to send back, or null if no response is needed.
+     *
+     * ## Example
+     * ```javascript
+     * // After unframing the multiplexed message:
+     * const response = await backend.injectBodySyncMessage(docName, data, true);
+     * if (response) ws.send(frameBodyMessage(docName, response));
+     * ```
+     */
+    injectBodySyncMessage(doc_name: string, message: Uint8Array, write_to_disk: boolean): Promise<any>;
+    /**
+     * Inject an incoming workspace sync message.
+     *
+     * Call this when the WebSocket receives a message for the workspace
+     * (metadata) connection. Returns a response message to send back,
+     * or null if no response is needed.
+     *
+     * ## Example
+     * ```javascript
+     * ws.onmessage = (event) => {
+     *   const data = new Uint8Array(event.data);
+     *   const response = backend.injectWorkspaceSyncMessage(data, true);
+     *   if (response) ws.send(response);
+     * };
+     * ```
+     */
+    injectWorkspaceSyncMessage(message: Uint8Array, write_to_disk: boolean): Promise<any>;
+    /**
+     * Unsubscribe from filesystem events.
+     *
+     * Returns `true` if the subscription was found and removed.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * const id = backend.onFileSystemEvent(handler);
+     * // ... later ...
+     * const removed = backend.offFileSystemEvent(id);
+     * console.log('Subscription removed:', removed);
+     * ```
+     */
+    offFileSystemEvent(id: bigint): boolean;
+    /**
+     * Subscribe to filesystem events.
+     *
+     * The callback will be invoked with a JSON-serialized FileSystemEvent
+     * whenever filesystem operations occur (create, delete, rename, move, etc.).
+     *
+     * Returns a subscription ID that can be used to unsubscribe later.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * const id = backend.onFileSystemEvent((eventJson) => {
+     *     const event = JSON.parse(eventJson);
+     *     console.log('File event:', event.type, event.path);
+     * });
+     *
+     * // Later, to unsubscribe:
+     * backend.offFileSystemEvent(id);
+     * ```
+     */
+    onFileSystemEvent(callback: Function): bigint;
+    /**
+     * Get count of pending outgoing sync messages.
+     */
+    outgoingSyncMessageCount(): number;
+    /**
+     * Poll for an outgoing sync message.
+     *
+     * Returns the next outgoing message as a JavaScript object with:
+     * - `docName`: Document name ("workspace" or file path)
+     * - `message`: Uint8Array message data
+     * - `isBody`: Boolean indicating body (true) or workspace (false)
+     *
+     * Returns null if no messages are queued.
+     *
+     * ## Example
+     * ```javascript
+     * setInterval(() => {
+     *   let msg;
+     *   while ((msg = backend.pollOutgoingSyncMessage()) !== null) {
+     *     if (msg.isBody) {
+     *       bodyWs.send(frameBodyMessage(msg.docName, msg.message));
+     *     } else {
+     *       workspaceWs.send(msg.message);
+     *     }
+     *   }
+     * }, 50);
+     * ```
+     */
+    pollOutgoingSyncMessage(): any;
+    /**
+     * Read binary file.
+     *
+     * Returns data as Uint8Array for efficient handling without base64 encoding.
+     */
+    readBinary(path: string): Promise<any>;
+    /**
+     * Save configuration to root index frontmatter.
+     * Config keys are stored as `diaryx_*` properties.
+     */
+    saveConfig(config_js: any): Promise<any>;
+    /**
+     * Start sync session and set up event bridge.
+     *
+     * This wires up the sync manager's event callback to queue outgoing
+     * messages. Call this before connecting WebSocket.
+     *
+     * ## Example
+     * ```javascript
+     * backend.startSync();
+     * const ws = new WebSocket(url);
+     * // ... rest of setup
+     * ```
+     */
+    startSync(): void;
+    /**
+     * Stop sync session.
+     *
+     * Clears the outgoing message queue. Call after disconnecting WebSocket.
+     */
+    stopSync(): void;
+    /**
+     * Write binary file.
+     *
+     * Accepts Uint8Array for efficient handling without base64 encoding.
+     */
+    writeBinary(path: string, data: Uint8Array): Promise<any>;
+}
+
+/**
+ * AsyncFileSystem implementation backed by File System Access API.
+ *
+ * Allows editing files directly on the user's filesystem in a directory
+ * they select via `showDirectoryPicker()`.
+ */
+export class FsaFileSystem {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new FsaFileSystem from a user-selected directory handle.
+     *
+     * The handle must be obtained from `window.showDirectoryPicker()` in JavaScript.
+     */
+    static fromHandle(handle: FileSystemDirectoryHandle): FsaFileSystem;
+}
+
+/**
+ * AsyncFileSystem implementation backed by IndexedDB.
+ *
+ * Used as a fallback for browsers that don't support OPFS or when
+ * running outside a Web Worker context (where OPFS sync access isn't available).
+ */
+export class IndexedDbFileSystem {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new IndexedDbFileSystem.
+     *
+     * Opens or creates the IndexedDB database with the required object stores.
+     */
+    static create(): Promise<IndexedDbFileSystem>;
+}
+
+/**
+ * An `AsyncFileSystem` implementation backed by JavaScript callbacks.
+ *
+ * This struct allows Rust code to use the async filesystem interface while
+ * delegating actual storage operations to JavaScript. This is useful for:
+ *
+ * - Using IndexedDB for persistent storage in browsers
+ * - Using OPFS (Origin Private File System) for better performance
+ * - Integrating with existing JavaScript storage solutions
+ * - Testing with mock filesystems
+ *
+ * ## Thread Safety
+ *
+ * This type is designed for single-threaded WASM environments. The callbacks
+ * JsValue is cloned into each async operation to satisfy Send requirements,
+ * but actual execution remains single-threaded.
+ */
+export class JsAsyncFileSystem {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check if the filesystem has a specific callback.
+     */
+    has_callback(name: string): boolean;
+    /**
+     * Create a new JsAsyncFileSystem with the provided callbacks.
+     *
+     * The callbacks object should implement the `JsFileSystemCallbacks` interface.
+     * All callbacks are optional - missing callbacks will cause operations to fail
+     * with appropriate errors.
+     */
+    constructor(callbacks: any);
+}
+
+/**
+ * AsyncFileSystem implementation backed by OPFS (Origin Private File System).
+ *
+ * Uses the browser's private file system for persistent storage.
+ * All operations are async and work directly with browser storage.
+ */
+export class OpfsFileSystem {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new OpfsFileSystem with the default app directory.
+     *
+     * This creates a "diaryx" directory in the origin-private file system.
+     */
+    static create(): Promise<OpfsFileSystem>;
+    /**
+     * Create a new OpfsFileSystem with a custom root directory name.
+     */
+    static createWithName(root_name: string): Promise<OpfsFileSystem>;
+}
+
+/**
+ * WASM sync client wrapper for JavaScript integration.
+ *
+ * This struct wraps a `SyncClient<CallbackTransport>` and exposes its
+ * functionality to JavaScript via wasm-bindgen. It manages two transports
+ * (metadata and body) and provides methods for:
+ *
+ * - Getting WebSocket URLs for connection
+ * - Notifying connection status changes
+ * - Injecting incoming messages
+ * - Polling for outgoing messages
+ * - Starting and stopping sync
+ */
+export class WasmSyncClient {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Focus on specific files for sync.
+     *
+     * Sends a focus message to the server indicating which files the client
+     * is currently interested in syncing. Other clients will receive a
+     * `focus_list_changed` notification and can subscribe to sync updates
+     * for these files.
+     *
+     * Call this when a file is opened in the editor.
+     *
+     * ## Example
+     * ```javascript
+     * // User opens a file
+     * client.focusFiles(["workspace/notes.md"]);
+     * ```
+     */
+    focusFiles(files: string[]): void;
+    /**
+     * Get the initial SyncStep1 message for a body document.
+     *
+     * Returns a Uint8Array containing the framed message to send via WebSocket.
+     */
+    getBodySyncStep1(doc_name: string): Uint8Array;
+    /**
+     * Get the WebSocket URL for the body connection.
+     *
+     * Returns null if sync hasn't been configured.
+     */
+    getBodyUrl(): string | undefined;
+    /**
+     * Get the WebSocket URL for the metadata connection.
+     *
+     * Returns null if sync hasn't been configured.
+     */
+    getMetadataUrl(): string | undefined;
+    /**
+     * Get the server URL.
+     */
+    getServerUrl(): string;
+    /**
+     * Get the workspace ID.
+     */
+    getWorkspaceId(): string;
+    /**
+     * Get the initial SyncStep1 message for workspace sync.
+     *
+     * Returns a Uint8Array containing the message to send via WebSocket.
+     */
+    getWorkspaceSyncStep1(): Uint8Array;
+    /**
+     * Check if there are pending body outgoing messages.
+     */
+    hasBodyOutgoing(): boolean;
+    /**
+     * Check if there are pending body outgoing text messages.
+     */
+    hasBodyOutgoingText(): boolean;
+    /**
+     * Check if there are pending metadata outgoing messages.
+     */
+    hasMetadataOutgoing(): boolean;
+    /**
+     * Inject an incoming body message.
+     *
+     * Call this when the body WebSocket receives a message.
+     * The message should already be unframed (doc_name extracted separately).
+     * Returns a Promise that resolves to a Uint8Array response (or null).
+     */
+    injectBodyMessage(doc_name: string, message: Uint8Array): Promise<any>;
+    /**
+     * Inject an incoming metadata message.
+     *
+     * Call this when the metadata WebSocket receives a message.
+     * Returns a Promise that resolves to a Uint8Array response (or null).
+     *
+     * The response should be sent back via the WebSocket if not null.
+     */
+    injectMetadataMessage(message: Uint8Array): Promise<any>;
+    /**
+     * Check if the body connection is established.
+     */
+    isBodyConnected(): boolean;
+    /**
+     * Check if both connections are established.
+     */
+    isConnected(): boolean;
+    /**
+     * Check if the metadata connection is established.
+     */
+    isMetadataConnected(): boolean;
+    /**
+     * Check if the sync client is running.
+     */
+    isRunning(): boolean;
+    /**
+     * Mark the body connection as connected.
+     *
+     * Call this when the body WebSocket opens.
+     */
+    markBodyConnected(): void;
+    /**
+     * Mark the body connection as disconnected.
+     *
+     * Call this when the body WebSocket closes.
+     */
+    markBodyDisconnected(): void;
+    /**
+     * Mark the metadata connection as connected.
+     *
+     * Call this when the metadata WebSocket opens.
+     */
+    markMetadataConnected(): void;
+    /**
+     * Mark the metadata connection as disconnected.
+     *
+     * Call this when the metadata WebSocket closes.
+     */
+    markMetadataDisconnected(): void;
+    /**
+     * Poll for an outgoing body message.
+     *
+     * Returns a Uint8Array if there's a message to send, null otherwise.
+     * The message is already framed with the document name.
+     */
+    pollBodyOutgoing(): Uint8Array | undefined;
+    /**
+     * Poll for an outgoing body text message (for focus/unfocus).
+     *
+     * Returns a string if there's a text message to send, null otherwise.
+     * JavaScript should call this in a polling loop and send any messages
+     * via the body WebSocket as text frames.
+     */
+    pollBodyOutgoingText(): string | undefined;
+    /**
+     * Poll for an outgoing metadata message.
+     *
+     * Returns a Uint8Array if there's a message to send, null otherwise.
+     * JavaScript should call this in a polling loop and send any messages
+     * via the metadata WebSocket.
+     */
+    pollMetadataOutgoing(): Uint8Array | undefined;
+    /**
+     * Queue a body update message for sending.
+     *
+     * This creates a Y-sync Update message for the given document
+     * and queues it for sending via the body WebSocket.
+     */
+    queueBodyUpdate(doc_name: string, content: string): void;
+    /**
+     * Queue a workspace update message for sending.
+     *
+     * This creates a Y-sync Update message from the current workspace state
+     * and queues it for sending via the metadata WebSocket.
+     */
+    queueWorkspaceUpdate(): void;
+    /**
+     * Start the sync session.
+     *
+     * This should be called after both WebSocket connections are established.
+     * It sends the initial SyncStep1 messages and subscribes to all body docs.
+     *
+     * Returns a Promise that resolves when initial sync messages are sent.
+     */
+    start(): Promise<any>;
+    /**
+     * Stop the sync session.
+     *
+     * Clears all pending messages and resets state.
+     */
+    stop(): void;
+    /**
+     * Subscribe to body sync for the currently focused files.
+     *
+     * This sends SyncStep1 messages for all files in the provided list.
+     * Call this after receiving a `focus_list_changed` message from the server.
+     *
+     * ## Example
+     * ```javascript
+     * // Received focus_list_changed event
+     * const files = event.files;
+     * client.subscribeBodies(files);
+     * ```
+     */
+    subscribeBodies(files: string[]): void;
+    /**
+     * Subscribe to body sync for a specific document.
+     *
+     * This queues a SyncStep1 message for the given document.
+     * Call this when a new file is created or when opening a file for editing.
+     */
+    subscribeBody(doc_name: string): void;
+    /**
+     * Unfocus specific files.
+     *
+     * Sends an unfocus message to the server indicating the client is no
+     * longer interested in syncing these files.
+     *
+     * Call this when a file is closed in the editor.
+     *
+     * ## Example
+     * ```javascript
+     * // User closes a file
+     * client.unfocusFiles(["workspace/notes.md"]);
+     * ```
+     */
+    unfocusFiles(files: string[]): void;
+}
+
+/**
+ * Initialize the WASM module. Called automatically on module load.
+ */
+export function init(): void;
+
+/**
+ * Generate an ISO 8601 timestamp for the current time.
+ */
+export function now_timestamp(): string;
+
+/**
+ * Generate a formatted date string for the current date.
+ */
+export function today_formatted(format: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_indexeddbfilesystem_free: (a: number, b: number) => void;
+    readonly __wbg_jsasyncfilesystem_free: (a: number, b: number) => void;
+    readonly indexeddbfilesystem_create: () => any;
+    readonly jsasyncfilesystem_has_callback: (a: number, b: number, c: number) => number;
+    readonly jsasyncfilesystem_new: (a: any) => number;
+    readonly __wbg_fsafilesystem_free: (a: number, b: number) => void;
+    readonly __wbg_opfsfilesystem_free: (a: number, b: number) => void;
+    readonly opfsfilesystem_create: () => any;
+    readonly opfsfilesystem_createWithName: (a: number, b: number) => any;
+    readonly fsafilesystem_fromHandle: (a: any) => number;
+    readonly now_timestamp: () => [number, number];
+    readonly today_formatted: (a: number, b: number) => [number, number];
+    readonly __wbg_diaryxbackend_free: (a: number, b: number) => void;
+    readonly diaryxbackend_create: (a: number, b: number) => any;
+    readonly diaryxbackend_createFromDirectoryHandle: (a: any) => [number, number, number];
+    readonly diaryxbackend_createInMemory: () => [number, number, number];
+    readonly diaryxbackend_createIndexedDb: () => any;
+    readonly diaryxbackend_createOpfs: () => any;
+    readonly diaryxbackend_createSyncClient: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly diaryxbackend_emitFileSystemEvent: (a: number, b: number, c: number) => [number, number];
+    readonly diaryxbackend_eventSubscriberCount: (a: number) => number;
+    readonly diaryxbackend_execute: (a: number, b: number, c: number) => any;
+    readonly diaryxbackend_executeJs: (a: number, b: any) => any;
+    readonly diaryxbackend_getBodySyncStep1: (a: number, b: number, c: number) => any;
+    readonly diaryxbackend_getConfig: (a: number) => any;
+    readonly diaryxbackend_getWorkspaceSyncStep1: (a: number) => any;
+    readonly diaryxbackend_hasNativeSync: (a: number) => number;
+    readonly diaryxbackend_hasOutgoingSyncMessages: (a: number) => number;
+    readonly diaryxbackend_injectBodySyncMessage: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+    readonly diaryxbackend_injectWorkspaceSyncMessage: (a: number, b: number, c: number, d: number) => any;
+    readonly diaryxbackend_offFileSystemEvent: (a: number, b: bigint) => number;
+    readonly diaryxbackend_onFileSystemEvent: (a: number, b: any) => bigint;
+    readonly diaryxbackend_outgoingSyncMessageCount: (a: number) => number;
+    readonly diaryxbackend_pollOutgoingSyncMessage: (a: number) => any;
+    readonly diaryxbackend_readBinary: (a: number, b: number, c: number) => any;
+    readonly diaryxbackend_saveConfig: (a: number, b: any) => any;
+    readonly diaryxbackend_startSync: (a: number) => void;
+    readonly diaryxbackend_stopSync: (a: number) => void;
+    readonly diaryxbackend_writeBinary: (a: number, b: number, c: number, d: any) => any;
+    readonly init: () => void;
+    readonly __wbg_wasmsyncclient_free: (a: number, b: number) => void;
+    readonly wasmsyncclient_focusFiles: (a: number, b: number, c: number) => void;
+    readonly wasmsyncclient_getBodySyncStep1: (a: number, b: number, c: number) => any;
+    readonly wasmsyncclient_getBodyUrl: (a: number) => [number, number];
+    readonly wasmsyncclient_getMetadataUrl: (a: number) => [number, number];
+    readonly wasmsyncclient_getServerUrl: (a: number) => [number, number];
+    readonly wasmsyncclient_getWorkspaceId: (a: number) => [number, number];
+    readonly wasmsyncclient_getWorkspaceSyncStep1: (a: number) => any;
+    readonly wasmsyncclient_hasBodyOutgoing: (a: number) => number;
+    readonly wasmsyncclient_hasBodyOutgoingText: (a: number) => number;
+    readonly wasmsyncclient_hasMetadataOutgoing: (a: number) => number;
+    readonly wasmsyncclient_injectBodyMessage: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmsyncclient_injectMetadataMessage: (a: number, b: number, c: number) => any;
+    readonly wasmsyncclient_isBodyConnected: (a: number) => number;
+    readonly wasmsyncclient_isConnected: (a: number) => number;
+    readonly wasmsyncclient_isMetadataConnected: (a: number) => number;
+    readonly wasmsyncclient_isRunning: (a: number) => number;
+    readonly wasmsyncclient_markBodyConnected: (a: number) => void;
+    readonly wasmsyncclient_markBodyDisconnected: (a: number) => void;
+    readonly wasmsyncclient_markMetadataConnected: (a: number) => void;
+    readonly wasmsyncclient_markMetadataDisconnected: (a: number) => void;
+    readonly wasmsyncclient_pollBodyOutgoing: (a: number) => any;
+    readonly wasmsyncclient_pollBodyOutgoingText: (a: number) => [number, number];
+    readonly wasmsyncclient_pollMetadataOutgoing: (a: number) => any;
+    readonly wasmsyncclient_queueBodyUpdate: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly wasmsyncclient_queueWorkspaceUpdate: (a: number) => [number, number];
+    readonly wasmsyncclient_start: (a: number) => any;
+    readonly wasmsyncclient_stop: (a: number) => void;
+    readonly wasmsyncclient_subscribeBodies: (a: number, b: number, c: number) => void;
+    readonly wasmsyncclient_subscribeBody: (a: number, b: number, c: number) => void;
+    readonly wasmsyncclient_unfocusFiles: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__closure__destroy__h137d52471f521a66: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h4b2a5ceca2370348: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__hf59ea51dfabf38c5: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h23e9ca6af2643a78: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__hcef8d709b492a91f: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hb2c8b70415be0174: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h1598c516b2d5b326: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha6231ef7710d1c67: (a: number, b: number, c: any) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;