@framers/sql-storage-adapter 0.7.1 → 0.7.3

package/dist/cjs/adapters/electron/electronRendererAdapter.js

@@ -0,0 +1,283 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var electronRendererAdapter_exports = {};
+__export(electronRendererAdapter_exports, {
+  ElectronRendererAdapter: () => ElectronRendererAdapter,
+  createElectronRendererAdapter: () => createElectronRendererAdapter,
+  isElectronRenderer: () => isElectronRenderer,
+  isPreloadApiAvailable: () => isPreloadApiAvailable
+});
+module.exports = __toCommonJS(electronRendererAdapter_exports);
+class ElectronRendererAdapter {
+  constructor(options = {}) {
+    this.kind = "electron-renderer";
+    this.eventUnsubscribers = [];
+    this.isInitialized = false;
+    this.cachedCapabilities = [];
+    this.options = options;
+    this.capabilities = /* @__PURE__ */ new Set([
+      "transactions",
+      "persistence",
+      "batch"
+    ]);
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  /**
+   * Get the preload API, throwing if not available.
+   */
+  getApi() {
+    if (typeof window === "undefined" || !window.sqlStorage) {
+      throw new Error("[ElectronRendererAdapter] window.sqlStorage not available. Ensure the preload script is loaded and contextBridge is properly configured.");
+    }
+    return window.sqlStorage;
+  }
+  /**
+   * Log a message if verbose mode is enabled.
+   */
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[ElectronRendererAdapter] ${message}`);
+    }
+  }
+  // ============================================================================
+  // Lifecycle Methods
+  // ============================================================================
+  /**
+   * Open connection to the database via main process.
+   */
+  async open(options) {
+    if (this.isInitialized) {
+      this.log("Already initialized, skipping open()");
+      return;
+    }
+    const api = this.getApi();
+    await api.open(options);
+    this.cachedCapabilities = await api.getCapabilities();
+    this.capabilities = new Set(this.cachedCapabilities);
+    this.subscribeToEvents();
+    this.isInitialized = true;
+    this.log("Connected to main process");
+  }
+  /**
+   * Close connection.
+   */
+  async close() {
+    if (!this.isInitialized) {
+      return;
+    }
+    for (const unsubscribe of this.eventUnsubscribers) {
+      unsubscribe();
+    }
+    this.eventUnsubscribers = [];
+    this.isInitialized = false;
+    this.log("Disconnected from main process");
+  }
+  /**
+   * Subscribe to database events from main process.
+   */
+  subscribeToEvents() {
+    const api = this.getApi();
+    if (this.options.onDatabaseChange) {
+      const unsubscribe = api.onDatabaseChange(this.options.onDatabaseChange);
+      this.eventUnsubscribers.push(unsubscribe);
+    }
+    if (this.options.onSyncProgress) {
+      const unsubscribe = api.onSyncProgress(this.options.onSyncProgress);
+      this.eventUnsubscribers.push(unsubscribe);
+    }
+    if (this.options.onSyncComplete) {
+      const unsubscribe = api.onSyncComplete(this.options.onSyncComplete);
+      this.eventUnsubscribers.push(unsubscribe);
+    }
+    if (this.options.onSyncError) {
+      const unsubscribe = api.onSyncError(this.options.onSyncError);
+      this.eventUnsubscribers.push(unsubscribe);
+    }
+  }
+  // ============================================================================
+  // Storage Adapter Interface
+  // ============================================================================
+  /**
+   * Execute a mutation statement (INSERT, UPDATE, DELETE).
+   */
+  async run(statement, parameters) {
+    this.assertOpen();
+    return this.getApi().run(statement, parameters);
+  }
+  /**
+   * Get a single row.
+   */
+  async get(statement, parameters) {
+    this.assertOpen();
+    return this.getApi().get(statement, parameters);
+  }
+  /**
+   * Get all matching rows.
+   */
+  async all(statement, parameters) {
+    this.assertOpen();
+    return this.getApi().all(statement, parameters);
+  }
+  /**
+   * Execute a SQL script.
+   */
+  async exec(script) {
+    this.assertOpen();
+    return this.getApi().exec(script);
+  }
+  /**
+   * Execute operations within a transaction.
+   */
+  async transaction(fn) {
+    this.assertOpen();
+    const trxAdapter = new TransactionProxyAdapter(this.getApi());
+    return this.getApi().transaction(async (trx) => {
+      const wrappedTrx = {
+        kind: "electron-renderer-transaction",
+        capabilities: this.capabilities,
+        open: async () => {
+        },
+        close: async () => {
+        },
+        run: trx.run,
+        get: trx.get,
+        all: trx.all,
+        exec: async () => {
+          throw new Error("exec not supported in transaction");
+        },
+        transaction: async () => {
+          throw new Error("Nested transactions not supported");
+        }
+      };
+      return fn(wrappedTrx);
+    });
+  }
+  /**
+   * Execute batch operations.
+   */
+  async batch(operations) {
+    this.assertOpen();
+    return this.getApi().batch(operations);
+  }
+  /**
+   * Prepared statements are not directly supported in renderer.
+   * Use the main process adapter for prepared statements.
+   */
+  prepare(_statement) {
+    throw new Error("Prepared statements not supported in renderer process. Use transactions instead.");
+  }
+  // ============================================================================
+  // Sync Operations
+  // ============================================================================
+  /**
+   * Get current sync status.
+   */
+  async getSyncStatus() {
+    this.assertOpen();
+    return this.getApi().getSyncStatus();
+  }
+  /**
+   * Trigger a manual sync.
+   */
+  async triggerSync() {
+    this.assertOpen();
+    return this.getApi().triggerSync();
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Assert that the adapter is open.
+   */
+  assertOpen() {
+    if (!this.isInitialized) {
+      throw new Error("[ElectronRendererAdapter] Adapter not open. Call open() first.");
+    }
+  }
+  /**
+   * Check if the adapter is open.
+   */
+  isOpen() {
+    return this.isInitialized;
+  }
+  /**
+   * Check if the main process database is open.
+   */
+  async isMainProcessOpen() {
+    try {
+      return await this.getApi().isOpen();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Add an event listener for database changes.
+   */
+  onDatabaseChange(callback) {
+    const unsubscribe = this.getApi().onDatabaseChange(callback);
+    this.eventUnsubscribers.push(unsubscribe);
+    return unsubscribe;
+  }
+}
+class TransactionProxyAdapter {
+  constructor(api) {
+    this.api = api;
+    this.kind = "electron-renderer-transaction";
+    this.capabilities = /* @__PURE__ */ new Set();
+  }
+  async open() {
+  }
+  async close() {
+  }
+  async run(statement, parameters) {
+    return this.api.run(statement, parameters);
+  }
+  async get(statement, parameters) {
+    return this.api.get(statement, parameters);
+  }
+  async all(statement, parameters) {
+    return this.api.all(statement, parameters);
+  }
+  async exec(_script) {
+    throw new Error("exec not supported within transactions from renderer");
+  }
+  async transaction(_fn) {
+    throw new Error("Nested transactions not supported");
+  }
+  async batch(_operations) {
+    throw new Error("Batch operations not supported within transactions from renderer");
+  }
+}
+function createElectronRendererAdapter(options = {}) {
+  return new ElectronRendererAdapter(options);
+}
+function isElectronRenderer() {
+  return typeof window !== "undefined" && typeof window.process === "object" && window.process?.type === "renderer";
+}
+function isPreloadApiAvailable() {
+  return typeof window !== "undefined" && !!window.sqlStorage;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElectronRendererAdapter,
+  createElectronRendererAdapter,
+  isElectronRenderer,
+  isPreloadApiAvailable
+});

package/dist/cjs/adapters/electron/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Electron Storage Adapter Module.
+ *
+ * Provides database access for Electron applications with:
+ * - Main process adapter (owns the database connection)
+ * - Renderer process adapter (IPC proxy to main)
+ * - Preload script for secure IPC bridge
+ * - WAL management and crash recovery
+ * - Multi-window change broadcasting
+ *
+ * ## Quick Start
+ *
+ * ### Main Process (main.ts)
+ * ```typescript
+ * import { createElectronMainAdapter } from '@framers/sql-storage-adapter/electron';
+ * import { app } from 'electron';
+ * import path from 'path';
+ *
+ * const db = createElectronMainAdapter({
+ *   filePath: path.join(app.getPath('userData'), 'app.db'),
+ *   wal: { enabled: true },
+ *   recovery: { checkOnOpen: true },
+ * });
+ *
+ * app.whenReady().then(async () => {
+ *   await db.open();
+ *   // Database ready for use
+ * });
+ * ```
+ *
+ * ### BrowserWindow Configuration
+ * ```typescript
+ * new BrowserWindow({
+ *   webPreferences: {
+ *     preload: path.join(__dirname, 'preload.js'),
+ *     contextIsolation: true,
+ *     nodeIntegration: false,
+ *   }
+ * });
+ * ```
+ *
+ * ### Preload Script (preload.ts)
+ * ```typescript
+ * // Just import the preload module - it auto-registers
+ * import '@framers/sql-storage-adapter/electron/preload';
+ * ```
+ *
+ * ### Renderer Process
+ * ```typescript
+ * import { createElectronRendererAdapter } from '@framers/sql-storage-adapter/electron';
+ *
+ * const db = createElectronRendererAdapter({
+ *   onDatabaseChange: (change) => {
+ *     console.log('Database changed:', change);
+ *   },
+ * });
+ *
+ * await db.open();
+ * const users = await db.all('SELECT * FROM users');
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { ElectronMainAdapter, createElectronMainAdapter, type ElectronMainAdapterOptions, type WalConfig, type RecoveryConfig, type MigrationConfig, type BackupConfig, type CloudBackupProvider, type MultiWindowConfig, } from './electronMainAdapter.js';
+export { ElectronRendererAdapter, createElectronRendererAdapter, isElectronRenderer, isPreloadApiAvailable, type ElectronRendererAdapterOptions, } from './electronRendererAdapter.js';
+export { sqlStorageApi, type SqlStorageApi, } from './preload.js';
+export { IPC_CHANNELS, DB_CHANNELS, TRANSACTION_CHANNELS, SYNC_CHANNELS, BACKUP_CHANNELS, RECOVERY_CHANNELS, MIGRATION_CHANNELS, BROADCAST_CHANNELS, type IpcChannel, } from './ipc/channels.js';
+export type { IpcRequest, IpcResponse, IpcError, SqlOperationPayload, ExecPayload, BatchPayload, OpenPayload, TransactionContext, TransactionOperationPayload, SyncStatus, BackupInfo, DbChangeEvent, ConnectionStateEvent, IntegrityCheckResult, WalCheckpointResult, MigrationStatus, } from './ipc/types.js';
+export { IpcProtocolManager, protocolManager, initializeIpcProtocol, disposeIpcProtocol, } from './ipc/protocol.js';
+export { WalCheckpointManager, createWalCheckpointManager, type WalCheckpointConfig, type CheckpointStrategy, type CheckpointResult, type WalStatus, CorruptionDetector, createCorruptionDetector, type CorruptionDetectorConfig, type IntegrityCheckLevel, type IntegrityCheckResult as RecoveryIntegrityCheckResult, type CorruptionIssue, type RepairStrategy, type RepairResult, } from './recovery/index.js';
+export { AutoMigrator, createAutoMigrator, type AutoMigratorConfig, type MigrationFile, type AppliedMigration, type MigrationResult, } from './migration/index.js';
+export { WindowManager, createWindowManager, type WindowManagerConfig, type WindowManagerCallbacks, type RegisteredWindow, } from './window/index.js';
+export type { StorageAdapter, StorageCapability, StorageOpenOptions, StorageParameters, StorageRunResult, BatchOperation, BatchResult, } from '../../core/contracts/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/adapters/electron/index.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var electron_exports = {};
+__export(electron_exports, {
+  AutoMigrator: () => import_migration.AutoMigrator,
+  BACKUP_CHANNELS: () => import_channels.BACKUP_CHANNELS,
+  BROADCAST_CHANNELS: () => import_channels.BROADCAST_CHANNELS,
+  CorruptionDetector: () => import_recovery.CorruptionDetector,
+  DB_CHANNELS: () => import_channels.DB_CHANNELS,
+  ElectronMainAdapter: () => import_electronMainAdapter.ElectronMainAdapter,
+  ElectronRendererAdapter: () => import_electronRendererAdapter.ElectronRendererAdapter,
+  IPC_CHANNELS: () => import_channels.IPC_CHANNELS,
+  IpcProtocolManager: () => import_protocol.IpcProtocolManager,
+  MIGRATION_CHANNELS: () => import_channels.MIGRATION_CHANNELS,
+  RECOVERY_CHANNELS: () => import_channels.RECOVERY_CHANNELS,
+  SYNC_CHANNELS: () => import_channels.SYNC_CHANNELS,
+  TRANSACTION_CHANNELS: () => import_channels.TRANSACTION_CHANNELS,
+  WalCheckpointManager: () => import_recovery.WalCheckpointManager,
+  WindowManager: () => import_window.WindowManager,
+  createAutoMigrator: () => import_migration.createAutoMigrator,
+  createCorruptionDetector: () => import_recovery.createCorruptionDetector,
+  createElectronMainAdapter: () => import_electronMainAdapter.createElectronMainAdapter,
+  createElectronRendererAdapter: () => import_electronRendererAdapter.createElectronRendererAdapter,
+  createWalCheckpointManager: () => import_recovery.createWalCheckpointManager,
+  createWindowManager: () => import_window.createWindowManager,
+  disposeIpcProtocol: () => import_protocol.disposeIpcProtocol,
+  initializeIpcProtocol: () => import_protocol.initializeIpcProtocol,
+  isElectronRenderer: () => import_electronRendererAdapter.isElectronRenderer,
+  isPreloadApiAvailable: () => import_electronRendererAdapter.isPreloadApiAvailable,
+  protocolManager: () => import_protocol.protocolManager,
+  sqlStorageApi: () => import_preload.sqlStorageApi
+});
+module.exports = __toCommonJS(electron_exports);
+var import_electronMainAdapter = require("./electronMainAdapter.js");
+var import_electronRendererAdapter = require("./electronRendererAdapter.js");
+var import_preload = require("./preload.js");
+var import_channels = require("./ipc/channels.js");
+var import_protocol = require("./ipc/protocol.js");
+var import_recovery = require("./recovery/index.js");
+var import_migration = require("./migration/index.js");
+var import_window = require("./window/index.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoMigrator,
+  BACKUP_CHANNELS,
+  BROADCAST_CHANNELS,
+  CorruptionDetector,
+  DB_CHANNELS,
+  ElectronMainAdapter,
+  ElectronRendererAdapter,
+  IPC_CHANNELS,
+  IpcProtocolManager,
+  MIGRATION_CHANNELS,
+  RECOVERY_CHANNELS,
+  SYNC_CHANNELS,
+  TRANSACTION_CHANNELS,
+  WalCheckpointManager,
+  WindowManager,
+  createAutoMigrator,
+  createCorruptionDetector,
+  createElectronMainAdapter,
+  createElectronRendererAdapter,
+  createWalCheckpointManager,
+  createWindowManager,
+  disposeIpcProtocol,
+  initializeIpcProtocol,
+  isElectronRenderer,
+  isPreloadApiAvailable,
+  protocolManager,
+  sqlStorageApi
+});

package/dist/cjs/adapters/electron/ipc/channels.d.ts

@@ -0,0 +1,196 @@
+/**
+ * IPC Channel Constants for Electron SQL Storage Adapter.
+ *
+ * All IPC communication between main and renderer processes
+ * uses these standardized channel names to ensure type safety
+ * and prevent channel name collisions.
+ *
+ * Channel naming convention: `sql-storage:{category}:{action}`
+ */
+/**
+ * Database operation channels.
+ */
+export declare const DB_CHANNELS: {
+    /** Execute a mutation (INSERT/UPDATE/DELETE) */
+    readonly RUN: "sql-storage:db:run";
+    /** Get a single row */
+    readonly GET: "sql-storage:db:get";
+    /** Get all matching rows */
+    readonly ALL: "sql-storage:db:all";
+    /** Execute a SQL script */
+    readonly EXEC: "sql-storage:db:exec";
+    /** Execute batch operations */
+    readonly BATCH: "sql-storage:db:batch";
+    /** Open database connection */
+    readonly OPEN: "sql-storage:db:open";
+    /** Close database connection */
+    readonly CLOSE: "sql-storage:db:close";
+    /** Check if database is open */
+    readonly IS_OPEN: "sql-storage:db:is-open";
+    /** Get adapter capabilities */
+    readonly CAPABILITIES: "sql-storage:db:capabilities";
+};
+/**
+ * Transaction channels.
+ */
+export declare const TRANSACTION_CHANNELS: {
+    /** Begin a transaction */
+    readonly BEGIN: "sql-storage:transaction:begin";
+    /** Commit current transaction */
+    readonly COMMIT: "sql-storage:transaction:commit";
+    /** Rollback current transaction */
+    readonly ROLLBACK: "sql-storage:transaction:rollback";
+    /** Execute operation within transaction context */
+    readonly EXECUTE: "sql-storage:transaction:execute";
+};
+/**
+ * Sync operation channels.
+ */
+export declare const SYNC_CHANNELS: {
+    /** Get sync status */
+    readonly STATUS: "sql-storage:sync:status";
+    /** Trigger manual sync */
+    readonly TRIGGER: "sql-storage:sync:trigger";
+    /** Sync progress updates (main -> renderer) */
+    readonly PROGRESS: "sql-storage:sync:progress";
+    /** Sync completed (main -> renderer) */
+    readonly COMPLETE: "sql-storage:sync:complete";
+    /** Sync error (main -> renderer) */
+    readonly ERROR: "sql-storage:sync:error";
+};
+/**
+ * Backup operation channels.
+ */
+export declare const BACKUP_CHANNELS: {
+    /** Trigger cloud backup */
+    readonly TRIGGER: "sql-storage:backup:trigger";
+    /** Backup progress (main -> renderer) */
+    readonly PROGRESS: "sql-storage:backup:progress";
+    /** Backup completed (main -> renderer) */
+    readonly COMPLETE: "sql-storage:backup:complete";
+    /** Restore from backup */
+    readonly RESTORE: "sql-storage:backup:restore";
+    /** List available backups */
+    readonly LIST: "sql-storage:backup:list";
+};
+/**
+ * Recovery operation channels.
+ */
+export declare const RECOVERY_CHANNELS: {
+    /** Run integrity check */
+    readonly CHECK_INTEGRITY: "sql-storage:recovery:check-integrity";
+    /** Trigger WAL checkpoint */
+    readonly WAL_CHECKPOINT: "sql-storage:recovery:wal-checkpoint";
+    /** Repair database */
+    readonly REPAIR: "sql-storage:recovery:repair";
+};
+/**
+ * Migration channels.
+ */
+export declare const MIGRATION_CHANNELS: {
+    /** Run pending migrations */
+    readonly RUN: "sql-storage:migration:run";
+    /** Get migration status */
+    readonly STATUS: "sql-storage:migration:status";
+    /** Rollback last migration */
+    readonly ROLLBACK: "sql-storage:migration:rollback";
+};
+/**
+ * Broadcast channels (main -> all renderers).
+ */
+export declare const BROADCAST_CHANNELS: {
+    /** Database change notification */
+    readonly DB_CHANGE: "sql-storage:broadcast:db-change";
+    /** Connection state change */
+    readonly CONNECTION_STATE: "sql-storage:broadcast:connection-state";
+    /** Error notification */
+    readonly ERROR: "sql-storage:broadcast:error";
+};
+/**
+ * All IPC channels grouped by category.
+ */
+export declare const IPC_CHANNELS: {
+    readonly db: {
+        /** Execute a mutation (INSERT/UPDATE/DELETE) */
+        readonly RUN: "sql-storage:db:run";
+        /** Get a single row */
+        readonly GET: "sql-storage:db:get";
+        /** Get all matching rows */
+        readonly ALL: "sql-storage:db:all";
+        /** Execute a SQL script */
+        readonly EXEC: "sql-storage:db:exec";
+        /** Execute batch operations */
+        readonly BATCH: "sql-storage:db:batch";
+        /** Open database connection */
+        readonly OPEN: "sql-storage:db:open";
+        /** Close database connection */
+        readonly CLOSE: "sql-storage:db:close";
+        /** Check if database is open */
+        readonly IS_OPEN: "sql-storage:db:is-open";
+        /** Get adapter capabilities */
+        readonly CAPABILITIES: "sql-storage:db:capabilities";
+    };
+    readonly transaction: {
+        /** Begin a transaction */
+        readonly BEGIN: "sql-storage:transaction:begin";
+        /** Commit current transaction */
+        readonly COMMIT: "sql-storage:transaction:commit";
+        /** Rollback current transaction */
+        readonly ROLLBACK: "sql-storage:transaction:rollback";
+        /** Execute operation within transaction context */
+        readonly EXECUTE: "sql-storage:transaction:execute";
+    };
+    readonly sync: {
+        /** Get sync status */
+        readonly STATUS: "sql-storage:sync:status";
+        /** Trigger manual sync */
+        readonly TRIGGER: "sql-storage:sync:trigger";
+        /** Sync progress updates (main -> renderer) */
+        readonly PROGRESS: "sql-storage:sync:progress";
+        /** Sync completed (main -> renderer) */
+        readonly COMPLETE: "sql-storage:sync:complete";
+        /** Sync error (main -> renderer) */
+        readonly ERROR: "sql-storage:sync:error";
+    };
+    readonly backup: {
+        /** Trigger cloud backup */
+        readonly TRIGGER: "sql-storage:backup:trigger";
+        /** Backup progress (main -> renderer) */
+        readonly PROGRESS: "sql-storage:backup:progress";
+        /** Backup completed (main -> renderer) */
+        readonly COMPLETE: "sql-storage:backup:complete";
+        /** Restore from backup */
+        readonly RESTORE: "sql-storage:backup:restore";
+        /** List available backups */
+        readonly LIST: "sql-storage:backup:list";
+    };
+    readonly recovery: {
+        /** Run integrity check */
+        readonly CHECK_INTEGRITY: "sql-storage:recovery:check-integrity";
+        /** Trigger WAL checkpoint */
+        readonly WAL_CHECKPOINT: "sql-storage:recovery:wal-checkpoint";
+        /** Repair database */
+        readonly REPAIR: "sql-storage:recovery:repair";
+    };
+    readonly migration: {
+        /** Run pending migrations */
+        readonly RUN: "sql-storage:migration:run";
+        /** Get migration status */
+        readonly STATUS: "sql-storage:migration:status";
+        /** Rollback last migration */
+        readonly ROLLBACK: "sql-storage:migration:rollback";
+    };
+    readonly broadcast: {
+        /** Database change notification */
+        readonly DB_CHANGE: "sql-storage:broadcast:db-change";
+        /** Connection state change */
+        readonly CONNECTION_STATE: "sql-storage:broadcast:connection-state";
+        /** Error notification */
+        readonly ERROR: "sql-storage:broadcast:error";
+    };
+};
+/**
+ * Union type of all channel values for type checking.
+ */
+export type IpcChannel = (typeof DB_CHANNELS)[keyof typeof DB_CHANNELS] | (typeof TRANSACTION_CHANNELS)[keyof typeof TRANSACTION_CHANNELS] | (typeof SYNC_CHANNELS)[keyof typeof SYNC_CHANNELS] | (typeof BACKUP_CHANNELS)[keyof typeof BACKUP_CHANNELS] | (typeof RECOVERY_CHANNELS)[keyof typeof RECOVERY_CHANNELS] | (typeof MIGRATION_CHANNELS)[keyof typeof MIGRATION_CHANNELS] | (typeof BROADCAST_CHANNELS)[keyof typeof BROADCAST_CHANNELS];
+//# sourceMappingURL=channels.d.ts.map