import { CompiledQuery } from "kysely";
import { QueryCallbackReturnType, useRelationalQueryOptions } from "@powerhousedao/reactor-browser";
import { IRelationalDb, IRelationalQueryBuilder, RelationalDbProcessorClass } from "@powerhousedao/shared/processors";

//#region ../../node_modules/.pnpm/@electric-sql+pglite@0.3.15/node_modules/@electric-sql/pglite/dist/pglite-CntadC_p.d.ts
type MessageName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
type BackendMessage = {
  name: MessageName;
  length: number;
};
interface NoticeOrError {
  message: string | undefined;
  severity: string | undefined;
  code: string | undefined;
  detail: string | undefined;
  hint: string | undefined;
  position: string | undefined;
  internalPosition: string | undefined;
  internalQuery: string | undefined;
  where: string | undefined;
  schema: string | undefined;
  table: string | undefined;
  column: string | undefined;
  dataType: string | undefined;
  constraint: string | undefined;
  file: string | undefined;
  line: string | undefined;
  routine: string | undefined;
}
declare class NoticeMessage implements BackendMessage, NoticeOrError {
  readonly length: number;
  readonly message: string | undefined;
  constructor(length: number, message: string | undefined);
  readonly name = "notice";
  severity: string | undefined;
  code: string | undefined;
  detail: string | undefined;
  hint: string | undefined;
  position: string | undefined;
  internalPosition: string | undefined;
  internalQuery: string | undefined;
  where: string | undefined;
  schema: string | undefined;
  table: string | undefined;
  column: string | undefined;
  dataType: string | undefined;
  constraint: string | undefined;
  file: string | undefined;
  line: string | undefined;
  routine: string | undefined;
}
type IDBFS = Emscripten.FileSystemType & {
  quit: () => void;
  dbs: Record<string, IDBDatabase>;
};
type FS = typeof FS & {
  filesystems: {
    MEMFS: Emscripten.FileSystemType;
    NODEFS: Emscripten.FileSystemType;
    IDBFS: IDBFS;
  };
  quit: () => void;
};
interface PostgresMod extends Omit<EmscriptenModule, 'preInit' | 'preRun' | 'postRun'> {
  preInit: Array<{
    (mod: PostgresMod): void;
  }>;
  preRun: Array<{
    (mod: PostgresMod): void;
  }>;
  postRun: Array<{
    (mod: PostgresMod): void;
  }>;
  FS: FS;
  FD_BUFFER_MAX: number;
  WASM_PREFIX: string;
  INITIAL_MEMORY: number;
  pg_extensions: Record<string, Promise<Blob | null>>;
  _pgl_initdb: () => number;
  _pgl_backend: () => void;
  _pgl_shutdown: () => void;
  _interactive_write: (msgLength: number) => void;
  _interactive_one: (length: number, peek: number) => void;
  _set_read_write_cbs: (read_cb: number, write_cb: number) => void;
  addFunction: (cb: (ptr: any, length: number) => void, signature: string) => number;
  removeFunction: (f: number) => void;
}
type DumpTarCompressionOptions = 'none' | 'gzip' | 'auto';
/**
 * Filesystem interface.
 * All virtual filesystems that are compatible with PGlite must implement
 * this interface.
 */
interface Filesystem {
  /**
   * Initiate the filesystem and return the options to pass to the emscripten module.
   */
  init(pg: PGlite, emscriptenOptions: Partial<PostgresMod>): Promise<{
    emscriptenOpts: Partial<PostgresMod>;
  }>;
  /**
   * Sync the filesystem to any underlying storage.
   */
  syncToFs(relaxedDurability?: boolean): Promise<void>;
  /**
   * Sync the filesystem from any underlying storage.
   */
  initialSyncFs(): Promise<void>;
  /**
   * Dump the PGDATA dir from the filesystem to a gzipped tarball.
   */
  dumpTar(dbname: string, compression?: DumpTarCompressionOptions): Promise<File | Blob>;
  /**
   * Close the filesystem.
   */
  closeFs(): Promise<void>;
}
/**
 * Base class for all emscripten built-in filesystems.
 */
type DebugLevel = 0 | 1 | 2 | 3 | 4 | 5;
type RowMode = 'array' | 'object';
interface ParserOptions {
  [pgType: number]: (value: string) => any;
}
interface SerializerOptions {
  [pgType: number]: (value: any) => string;
}
interface QueryOptions {
  rowMode?: RowMode;
  parsers?: ParserOptions;
  serializers?: SerializerOptions;
  blob?: Blob | File;
  onNotice?: (notice: NoticeMessage) => void;
  paramTypes?: number[];
}
interface ExecProtocolOptions {
  syncToFs?: boolean;
  throwOnError?: boolean;
  onNotice?: (notice: NoticeMessage) => void;
}
interface ExtensionSetupResult<TNamespace = any> {
  emscriptenOpts?: any;
  namespaceObj?: TNamespace;
  bundlePath?: URL;
  init?: () => Promise<void>;
  close?: () => Promise<void>;
}
type ExtensionSetup<TNamespace = any> = (pg: PGliteInterface, emscriptenOpts: any, clientOnly?: boolean) => Promise<ExtensionSetupResult<TNamespace>>;
interface Extension<TNamespace = any> {
  name: string;
  setup: ExtensionSetup<TNamespace>;
}
type ExtensionNamespace<T> = T extends Extension<infer TNamespace> ? TNamespace : any;
type Extensions = {
  [namespace: string]: Extension | URL;
};
type InitializedExtensions<TExtensions extends Extensions = Extensions> = { [K in keyof TExtensions]: ExtensionNamespace<TExtensions[K]> };
interface ExecProtocolResult {
  messages: BackendMessage[];
  data: Uint8Array;
}
interface PGliteOptions<TExtensions extends Extensions = Extensions> {
  dataDir?: string;
  username?: string;
  database?: string;
  fs?: Filesystem;
  debug?: DebugLevel;
  relaxedDurability?: boolean;
  extensions?: TExtensions;
  loadDataDir?: Blob | File;
  initialMemory?: number;
  wasmModule?: WebAssembly.Module;
  fsBundle?: Blob | File;
  parsers?: ParserOptions;
  serializers?: SerializerOptions;
}
type PGliteInterface<T extends Extensions = Extensions> = InitializedExtensions<T> & {
  readonly waitReady: Promise<void>;
  readonly debug: DebugLevel;
  readonly ready: boolean;
  readonly closed: boolean;
  close(): Promise<void>;
  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
  describeQuery(query: string): Promise<DescribeQueryResult>;
  transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
  execProtocolRaw(message: Uint8Array, options?: ExecProtocolOptions): Promise<Uint8Array>;
  execProtocol(message: Uint8Array, options?: ExecProtocolOptions): Promise<ExecProtocolResult>;
  runExclusive<T>(fn: () => Promise<T>): Promise<T>;
  listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
  unlisten(channel: string, callback?: (payload: string) => void, tx?: Transaction): Promise<void>;
  onNotification(callback: (channel: string, payload: string) => void): () => void;
  offNotification(callback: (channel: string, payload: string) => void): void;
  dumpDataDir(compression?: DumpTarCompressionOptions): Promise<File | Blob>;
  refreshArrayTypes(): Promise<void>;
};
type PGliteInterfaceExtensions<E> = E extends Extensions ? { [K in keyof E]: E[K] extends Extension ? Awaited<ReturnType<E[K]['setup']>>['namespaceObj'] extends infer N ? N extends undefined | null | void ? never : N : never : never } : Record<string, never>;
type Row<T = {
  [key: string]: any;
}> = T;
type Results<T = {
  [key: string]: any;
}> = {
  rows: Row<T>[];
  affectedRows?: number;
  fields: {
    name: string;
    dataTypeID: number;
  }[];
  blob?: Blob;
};
interface Transaction {
  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
  rollback(): Promise<void>;
  listen(channel: string, callback: (payload: string) => void): Promise<(tx?: Transaction) => Promise<void>>;
  get closed(): boolean;
}
type DescribeQueryResult = {
  queryParams: {
    dataTypeID: number;
    serializer: Serializer;
  }[];
  resultFields: {
    name: string;
    dataTypeID: number;
    parser: Parser;
  }[];
};
type Parser = (x: string, typeId?: number) => any;
type Serializer = (x: any) => string;
declare abstract class BasePGlite implements Pick<PGliteInterface, 'query' | 'sql' | 'exec' | 'transaction'> {
  #private;
  serializers: Record<number | string, Serializer>;
  parsers: Record<number | string, Parser>;
  abstract debug: DebugLevel;
  /**
   * Execute a postgres wire protocol message
   * @param message The postgres wire protocol message to execute
   * @returns The result of the query
   */
  abstract execProtocol(message: Uint8Array, {
    syncToFs,
    onNotice
  }: ExecProtocolOptions): Promise<ExecProtocolResult>;
  /**
   * Execute a postgres wire protocol message
   * @param message The postgres wire protocol message to execute
   * @returns The parsed results of the query
   */
  abstract execProtocolStream(message: Uint8Array, {
    syncToFs,
    onNotice
  }: ExecProtocolOptions): Promise<BackendMessage[]>;
  /**
   * Execute a postgres wire protocol message directly without wrapping the response.
   * Only use if `execProtocol()` doesn't suite your needs.
   *
   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
   * don't intend to use the above features.
   *
   * @param message The postgres wire protocol message to execute
   * @returns The direct message data response produced by Postgres
   */
  abstract execProtocolRaw(message: Uint8Array, {
    syncToFs
  }: ExecProtocolOptions): Promise<Uint8Array>;
  /**
   * Sync the database to the filesystem
   * @returns Promise that resolves when the database is synced to the filesystem
   */
  abstract syncToFs(): Promise<void>;
  /**
   * Handle a file attached to the current query
   * @param file The file to handle
   */
  abstract _handleBlob(blob?: File | Blob): Promise<void>;
  /**
   * Get the written file
   */
  abstract _getWrittenBlob(): Promise<File | Blob | undefined>;
  /**
   * Cleanup the current file
   */
  abstract _cleanupBlob(): Promise<void>;
  abstract _checkReady(): Promise<void>;
  abstract _runExclusiveQuery<T>(fn: () => Promise<T>): Promise<T>;
  abstract _runExclusiveTransaction<T>(fn: () => Promise<T>): Promise<T>;
  /**
   * Listen for notifications on a channel
   */
  abstract listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
  /**
   * Initialize the array types
   * The oid if the type of an element and the typarray is the oid of the type of the
   * array.
   * We extract these from the database then create the serializers/parsers for
   * each type.
   * This should be called at the end of #init() in the implementing class.
   */
  _initArrayTypes({
    force
  }?: {
    force?: boolean | undefined;
  }): Promise<void>;
  /**
   * Re-syncs the array types from the database
   * This is useful if you add a new type to the database and want to use it, otherwise pglite won't recognize it.
   */
  refreshArrayTypes(): Promise<void>;
  /**
   * Execute a single SQL statement
   * This uses the "Extended Query" postgres wire protocol message.
   * @param query The query to execute
   * @param params Optional parameters for the query
   * @returns The result of the query
   */
  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
  /**
   * Execute a single SQL statement like with {@link PGlite.query}, but with a
   * templated statement where template values will be treated as parameters.
   *
   * You can use helpers from `/template` to further format the query with
   * identifiers, raw SQL, and nested statements.
   *
   * This uses the "Extended Query" postgres wire protocol message.
   *
   * @param query The query to execute with parameters as template values
   * @returns The result of the query
   *
   * @example
   * ```ts
   * const results = await db.sql`SELECT * FROM ${identifier`foo`} WHERE id = ${id}`
   * ```
   */
  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
  /**
   * Execute a SQL query, this can have multiple statements.
   * This uses the "Simple Query" postgres wire protocol message.
   * @param query The query to execute
   * @returns The result of the query
   */
  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
  /**
   * Describe a query
   * @param query The query to describe
   * @returns A description of the result types for the query
   */
  describeQuery(query: string, options?: QueryOptions): Promise<DescribeQueryResult>;
  /**
   * Execute a transaction
   * @param callback A callback function that takes a transaction object
   * @returns The result of the transaction
   */
  transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
  /**
   * Run a function exclusively, no other transactions or queries will be allowed
   * while the function is running.
   * This is useful when working with the execProtocol methods as they are not blocked,
   * and do not block the locks used by transactions and queries.
   * @param fn The function to run
   * @returns The result of the function
   */
  runExclusive<T>(fn: () => Promise<T>): Promise<T>;
}
declare class PGlite extends BasePGlite implements PGliteInterface, AsyncDisposable {
  #private;
  fs?: Filesystem;
  protected mod?: PostgresMod;
  readonly dataDir?: string;
  readonly waitReady: Promise<void>;
  readonly debug: DebugLevel;
  static readonly DEFAULT_RECV_BUF_SIZE: number;
  static readonly MAX_BUFFER_SIZE: number;
  /**
   * Create a new PGlite instance
   * @param dataDir The directory to store the database files
   *                Prefix with idb:// to use indexeddb filesystem in the browser
   *                Use memory:// to use in-memory filesystem
   * @param options PGlite options
   */
  constructor(dataDir?: string, options?: PGliteOptions);
  /**
   * Create a new PGlite instance
   * @param options PGlite options including the data directory
   */
  constructor(options?: PGliteOptions);
  /**
   * Create a new PGlite instance with extensions on the Typescript interface
   * (The main constructor does enable extensions, however due to the limitations
   * of Typescript, the extensions are not available on the instance interface)
   * @param options PGlite options including the data directory
   * @returns A promise that resolves to the PGlite instance when it's ready.
   */
  static create<O extends PGliteOptions>(options?: O): Promise<PGlite & PGliteInterfaceExtensions<O['extensions']>>;
  /**
   * Create a new PGlite instance with extensions on the Typescript interface
   * (The main constructor does enable extensions, however due to the limitations
   * of Typescript, the extensions are not available on the instance interface)
   * @param dataDir The directory to store the database files
   *                Prefix with idb:// to use indexeddb filesystem in the browser
   *                Use memory:// to use in-memory filesystem
   * @param options PGlite options
   * @returns A promise that resolves to the PGlite instance when it's ready.
   */
  static create<O extends PGliteOptions>(dataDir?: string, options?: O): Promise<PGlite & PGliteInterfaceExtensions<O['extensions']>>;
  /**
   * The Postgres Emscripten Module
   */
  get Module(): PostgresMod;
  /**
   * The ready state of the database
   */
  get ready(): boolean;
  /**
   * The closed state of the database
   */
  get closed(): boolean;
  /**
   * Close the database
   * @returns A promise that resolves when the database is closed
   */
  close(): Promise<void>;
  /**
   * Close the database when the object exits scope
   * Stage 3 ECMAScript Explicit Resource Management
   * https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management
   */
  [Symbol.asyncDispose](): Promise<void>;
  /**
   * Handle a file attached to the current query
   * @param file The file to handle
   */
  _handleBlob(blob?: File | Blob): Promise<void>;
  /**
   * Cleanup the current file
   */
  _cleanupBlob(): Promise<void>;
  /**
   * Get the written blob from the current query
   * @returns The written blob
   */
  _getWrittenBlob(): Promise<Blob | undefined>;
  /**
   * Wait for the database to be ready
   */
  _checkReady(): Promise<void>;
  /**
   * Execute a postgres wire protocol synchronously
   * @param message The postgres wire protocol message to execute
   * @returns The direct message data response produced by Postgres
   */
  execProtocolRawSync(message: Uint8Array): Uint8Array;
  /**
   * Execute a postgres wire protocol message directly without wrapping the response.
   * Only use if `execProtocol()` doesn't suite your needs.
   *
   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
   * don't intend to use the above features.
   *
   * @param message The postgres wire protocol message to execute
   * @returns The direct message data response produced by Postgres
   */
  execProtocolRaw(message: Uint8Array, {
    syncToFs
  }?: ExecProtocolOptions): Promise<Uint8Array>;
  /**
   * Execute a postgres wire protocol message
   * @param message The postgres wire protocol message to execute
   * @returns The result of the query
   */
  execProtocol(message: Uint8Array, {
    syncToFs,
    throwOnError,
    onNotice
  }?: ExecProtocolOptions): Promise<ExecProtocolResult>;
  /**
   * Execute a postgres wire protocol message
   * @param message The postgres wire protocol message to execute
   * @returns The parsed results of the query
   */
  execProtocolStream(message: Uint8Array, {
    syncToFs,
    throwOnError,
    onNotice
  }?: ExecProtocolOptions): Promise<BackendMessage[]>;
  /**
   * Check if the database is in a transaction
   * @returns True if the database is in a transaction, false otherwise
   */
  isInTransaction(): boolean;
  /**
   * Perform any sync operations implemented by the filesystem, this is
   * run after every query to ensure that the filesystem is synced.
   */
  syncToFs(): Promise<void>;
  /**
   * Listen for a notification
   * @param channel The channel to listen on
   * @param callback The callback to call when a notification is received
   */
  listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
  /**
   * Stop listening for a notification
   * @param channel The channel to stop listening on
   * @param callback The callback to remove
   */
  unlisten(channel: string, callback?: (payload: string) => void, tx?: Transaction): Promise<void>;
  /**
   * Listen to notifications
   * @param callback The callback to call when a notification is received
   */
  onNotification(callback: (channel: string, payload: string) => void): () => void;
  /**
   * Stop listening to notifications
   * @param callback The callback to remove
   */
  offNotification(callback: (channel: string, payload: string) => void): void;
  /**
   * Dump the PGDATA dir from the filesystem to a gzipped tarball.
   * @param compression The compression options to use - 'gzip', 'auto', 'none'
   * @returns The tarball as a File object where available, and fallback to a Blob
   */
  dumpDataDir(compression?: DumpTarCompressionOptions): Promise<File | Blob>;
  /**
   * Run a function in a mutex that's exclusive to queries
   * @param fn The query to run
   * @returns The result of the query
   */
  _runExclusiveQuery<T>(fn: () => Promise<T>): Promise<T>;
  /**
   * Run a function in a mutex that's exclusive to transactions
   * @param fn The function to run
   * @returns The result of the function
   */
  _runExclusiveTransaction<T>(fn: () => Promise<T>): Promise<T>;
  clone(): Promise<PGliteInterface>;
  _runExclusiveListen<T>(fn: () => Promise<T>): Promise<T>;
}
//#endregion
//#region ../../node_modules/.pnpm/@electric-sql+pglite@0.3.15/node_modules/@electric-sql/pglite/dist/live/index.d.ts
interface LiveQueryOptions<T = {
  [key: string]: any;
}> {
  query: string;
  params?: any[] | null;
  offset?: number;
  limit?: number;
  callback?: (results: Results<T>) => void;
  signal?: AbortSignal;
}
interface LiveChangesOptions<T = {
  [key: string]: any;
}> {
  query: string;
  params?: any[] | null;
  key: string;
  callback?: (changes: Array<Change<T>>) => void;
  signal?: AbortSignal;
}
interface LiveIncrementalQueryOptions<T = {
  [key: string]: any;
}> {
  query: string;
  params?: any[] | null;
  key: string;
  callback?: (results: Results<T>) => void;
  signal?: AbortSignal;
}
interface LiveNamespace {
  /**
   * Create a live query
   * @param query - The query to run
   * @param params - The parameters to pass to the query
   * @param callback - A callback to run when the query is updated
   * @returns A promise that resolves to an object with the initial results,
   * an unsubscribe function, and a refresh function
   */
  query<T = {
    [key: string]: any;
  }>(query: string, params?: any[] | null, callback?: (results: Results<T>) => void): Promise<LiveQuery<T>>;
  /**
   * Create a live query
   * @param options - The options to pass to the query
   * @returns A promise that resolves to an object with the initial results,
   * an unsubscribe function, and a refresh function
   */
  query<T = {
    [key: string]: any;
  }>(options: LiveQueryOptions<T>): Promise<LiveQuery<T>>;
  /**
   * Create a live query that returns the changes to the query results
   * @param query - The query to run
   * @param params - The parameters to pass to the query
   * @param callback - A callback to run when the query is updated
   * @returns A promise that resolves to an object with the initial changes,
   * an unsubscribe function, and a refresh function
   */
  changes<T = {
    [key: string]: any;
  }>(query: string, params: any[] | undefined | null, key: string, callback?: (changes: Array<Change<T>>) => void): Promise<LiveChanges<T>>;
  /**
   * Create a live query that returns the changes to the query results
   * @param options - The options to pass to the query
   * @returns A promise that resolves to an object with the initial changes,
   * an unsubscribe function, and a refresh function
   */
  changes<T = {
    [key: string]: any;
  }>(options: LiveChangesOptions<T>): Promise<LiveChanges<T>>;
  /**
   * Create a live query with incremental updates
   * @param query - The query to run
   * @param params - The parameters to pass to the query
   * @param callback - A callback to run when the query is updated
   * @returns A promise that resolves to an object with the initial results,
   * an unsubscribe function, and a refresh function
   */
  incrementalQuery<T = {
    [key: string]: any;
  }>(query: string, params: any[] | undefined | null, key: string, callback?: (results: Results<T>) => void): Promise<LiveQuery<T>>;
  /**
   * Create a live query with incremental updates
   * @param options - The options to pass to the query
   * @returns A promise that resolves to an object with the initial results,
   * an unsubscribe function, and a refresh function
   */
  incrementalQuery<T = {
    [key: string]: any;
  }>(options: LiveIncrementalQueryOptions<T>): Promise<LiveQuery<T>>;
}
interface LiveQueryResults<T> extends Results<T> {
  totalCount?: number;
  offset?: number;
  limit?: number;
}
interface LiveQuery<T> {
  initialResults: LiveQueryResults<T>;
  subscribe: (callback: (results: LiveQueryResults<T>) => void) => void;
  unsubscribe: (callback?: (results: LiveQueryResults<T>) => void) => Promise<void>;
  refresh: (options?: {
    offset?: number;
    limit?: number;
  }) => Promise<void>;
}
interface LiveChanges<T = {
  [key: string]: any;
}> {
  fields: {
    name: string;
    dataTypeID: number;
  }[];
  initialChanges: Array<Change<T>>;
  subscribe: (callback: (changes: Array<Change<T>>) => void) => void;
  unsubscribe: (callback?: (changes: Array<Change<T>>) => void) => Promise<void>;
  refresh: () => Promise<void>;
}
type ChangeInsert<T> = {
  __changed_columns__: string[];
  __op__: 'INSERT';
  __after__: number;
} & T;
type ChangeDelete<T> = {
  __changed_columns__: string[];
  __op__: 'DELETE';
  __after__: undefined;
} & T;
type ChangeUpdate<T> = {
  __changed_columns__: string[];
  __op__: 'UPDATE';
  __after__: number;
} & T;
type ChangeReset<T> = {
  __op__: 'RESET';
} & T;
type Change<T> = ChangeInsert<T> | ChangeDelete<T> | ChangeUpdate<T> | ChangeReset<T>;
type PGliteWithLive = PGliteInterface & {
  live: LiveNamespace;
};
//#endregion
//#region src/relational/hooks/useRelationalDb.d.ts
type RelationalDbWithLive<Schema> = IRelationalDb<Schema> & {
  live: LiveNamespace;
};
interface IRelationalDbState<Schema> {
  db: RelationalDbWithLive<Schema> | null;
  isLoading: boolean;
  error: Error | null;
}
declare const useRelationalDb: <Schema>() => IRelationalDbState<Schema>;
//#endregion
//#region src/relational/hooks/useRelationalQuery.d.ts
type QueryCallbackReturnType$1 = {
  sql: string;
  parameters?: readonly unknown[];
};
type useRelationalQueryOptions$1 = {
  hashNamespace?: boolean;
};
declare function useRelationalQuery<Schema, T = unknown, TParams = undefined>(ProcessorClass: RelationalDbProcessorClass<Schema>, driveId: string, queryCallback: (db: IRelationalQueryBuilder<Schema>, parameters?: TParams) => QueryCallbackReturnType$1, parameters?: TParams, _options?: useRelationalQueryOptions$1): {
  readonly isLoading: boolean;
  readonly error: Error | null;
  readonly result: LiveQueryResults<T> | null;
};
//#endregion
//#region src/relational/utils/createProcessorQuery.d.ts
declare function createProcessorQuery<TSchema>(ProcessorClass: RelationalDbProcessorClass<TSchema>): {
  <TQueryBuilder extends (db: IRelationalQueryBuilder<TSchema>) => QueryCallbackReturnType>(driveId: string, queryCallback: TQueryBuilder): {
    isLoading: boolean;
    error: Error | null;
    result: LiveQueryResults<ReturnType<TQueryBuilder> extends CompiledQuery<infer R> ? R : any> | null;
  };
  <TParams, TQueryBuilder extends (db: IRelationalQueryBuilder<TSchema>, parameters: TParams) => QueryCallbackReturnType>(driveId: string, queryCallback: TQueryBuilder, parameters: TParams, options?: useRelationalQueryOptions): {
    isLoading: boolean;
    error: Error | null;
    result: LiveQueryResults<ReturnType<TQueryBuilder> extends CompiledQuery<infer R> ? R : any> | null;
  };
};
//#endregion
export { type RelationalDbWithLive as a, type PGlite as c, type useRelationalQueryOptions$1 as i, type QueryCallbackReturnType$1 as n, type useRelationalDb as o, type useRelationalQuery as r, type PGliteWithLive as s, createProcessorQuery as t };
//# sourceMappingURL=index-ZltD7u5Z.d.ts.map