@harperfast/rocksdb-js 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1152 @@
+import { ExtendedIterable } from "@harperfast/extended-iterable";
+
+//#region src/encoding.d.ts
+type Key = Key[] | string | symbol | number | boolean | Uint8Array | Buffer | null;
+interface BufferWithDataView extends Buffer {
+  dataView: DataView;
+  start: number;
+  end: number;
+}
+type EncoderFunction = new (options?: any) => Encoder;
+interface Encoder {
+  copyBuffers?: boolean;
+  decode?: (buffer: BufferWithDataView, options?: {
+    end: number;
+  }) => any;
+  encode?: (value: any, mode?: number) => Buffer;
+  Encoder?: EncoderFunction;
+  freezeData?: boolean;
+  needsStableBuffer?: boolean;
+  randomAccessStructure?: boolean;
+  readKey?: (buffer: Buffer, start: number, end: number, inSequence?: boolean) => any;
+  structuredClone?: boolean;
+  structures?: any[];
+  useFloat32?: boolean;
+  writeKey?: (key: any, target: Buffer, position: number, inSequence?: boolean) => number;
+}
+type Encoding = "binary" | "ordered-binary" | "msgpack" | false;
+type KeyEncoding = "binary" | "ordered-binary" | "uint32";
+type ReadKeyFunction<T> = (source: BufferWithDataView, start: number, end?: number) => T;
+type WriteKeyFunction = (key: Key, target: BufferWithDataView, start: number) => number;
+//#endregion
+//#region src/dbi-iterator.d.ts
+interface DBIteratorValue<T> {
+  key: Key;
+  value: T;
+}
+/**
+* Wraps an iterator, namely the `NativeIterator` class, and decodes the key
+* and value.
+*/
+declare class DBIterator<T> implements Iterator<DBIteratorValue<T>> {
+  #private;
+  iterator: Iterator<DBIteratorValue<T>>;
+  store: Store;
+  constructor(iterator: Iterator<DBIteratorValue<T>>, store: Store, options?: IteratorOptions & T);
+  [Symbol.iterator](): Iterator<DBIteratorValue<T>>;
+  next(...[_value]: [] | [any]): IteratorResult<DBIteratorValue<T>>;
+  return(value?: any): IteratorResult<DBIteratorValue<T>, any>;
+  throw(err: unknown): IteratorResult<DBIteratorValue<T>, any>;
+}
+//#endregion
+//#region src/store.d.ts
+type Context = NativeDatabase | NativeTransaction;
+/**
+* Options for the `Store` class.
+*/
+interface StoreOptions extends Omit<NativeDatabaseOptions, "mode" | "transactionLogRetentionMs"> {
+  decoder?: Encoder | null;
+  encoder?: Encoder | null;
+  encoding?: Encoding;
+  freezeData?: boolean;
+  keyEncoder?: {
+    readKey?: ReadKeyFunction<Key>;
+    writeKey?: WriteKeyFunction;
+  };
+  keyEncoding?: KeyEncoding;
+  maxKeySize?: number;
+  pessimistic?: boolean;
+  /**
+  * If `true`, the encoder will use a random access structure.
+  */
+  randomAccessStructure?: boolean;
+  sharedStructuresKey?: symbol;
+  /**
+  * A string containing the amount of time or the number of milliseconds to
+  * retain transaction logs before purging.
+  *
+  * @default '3d' (3 days)
+  */
+  transactionLogRetention?: number | string;
+}
+/**
+* Options for the `getUserSharedBuffer()` method.
+*/
+type UserSharedBufferOptions = {
+  callback?: UserSharedBufferCallback;
+};
+/**
+* The return type of `getUserSharedBuffer()`.
+*/
+type ArrayBufferWithNotify = ArrayBuffer & {
+  cancel: () => void;
+  notify: () => void;
+};
+/**
+* A store wraps the `NativeDatabase` binding and database settings so that a
+* single database instance can be shared between the main `RocksDatabase`
+* instance and the `Transaction` instance.
+*
+* This store should not be shared between `RocksDatabase` instances.
+*/
+declare class Store {
+  /**
+  * The database instance.
+  */
+  db: NativeDatabase;
+  /**
+  * The decoder instance. This is commonly the same as the `encoder`
+  * instance.
+  */
+  decoder: Encoder | null;
+  /**
+  * Whether the decoder copies the buffer when encoding values.
+  */
+  decoderCopies: boolean;
+  /**
+  * Whether to disable the write ahead log.
+  */
+  disableWAL: boolean;
+  /**
+  * Reusable buffer for encoding values using `writeKey()` when the custom
+  * encoder does not provide a `encode()` method.
+  */
+  encodeBuffer: BufferWithDataView;
+  /**
+  * The encoder instance.
+  */
+  encoder: Encoder | null;
+  /**
+  * The encoding used to encode values. Defaults to `'msgpack'` in
+  * `RocksDatabase.open()`.
+  */
+  encoding: Encoding | null;
+  /**
+  * Encoder specific option used to signal that the data should be frozen.
+  */
+  freezeData: boolean;
+  /**
+  * Reusable buffer for encoding keys.
+  */
+  keyBuffer: BufferWithDataView;
+  /**
+  * The key encoding to use for keys. Defaults to `'ordered-binary'`.
+  */
+  keyEncoding: KeyEncoding;
+  /**
+  * The maximum key size.
+  */
+  maxKeySize: number;
+  /**
+  * The name of the store (e.g. the column family). Defaults to `'default'`.
+  */
+  name: string;
+  /**
+  * Whether to disable the block cache.
+  */
+  noBlockCache?: boolean;
+  /**
+  * The number of threads to use for parallel operations. This is a RocksDB
+  * option.
+  */
+  parallelismThreads: number;
+  /**
+  * The path to the database.
+  */
+  path: string;
+  /**
+  * Whether to use pessimistic locking for transactions. When `true`,
+  * transactions will fail as soon as a conflict is detected. When `false`,
+  * transactions will only fail when `commit()` is called.
+  */
+  pessimistic: boolean;
+  /**
+  * Encoder specific flag used to signal that the encoder should use a random
+  * access structure.
+  */
+  randomAccessStructure: boolean;
+  /**
+  * The function used to encode keys.
+  */
+  readKey: ReadKeyFunction<Key>;
+  /**
+  * The key used to store shared structures.
+  */
+  sharedStructuresKey?: symbol;
+  /**
+  * The threshold for the transaction log file's last modified time to be
+  * older than the retention period before it is rotated to the next sequence
+  * number. A threshold of 0 means ignore age check.
+  */
+  transactionLogMaxAgeThreshold?: number;
+  /**
+  * The maximum size of a transaction log before it is rotated to the next
+  * sequence number.
+  */
+  transactionLogMaxSize?: number;
+  /**
+  * A string containing the amount of time or the number of milliseconds to
+  * retain transaction logs before purging.
+  *
+  * @default '3d' (3 days)
+  */
+  transactionLogRetention?: number | string;
+  /**
+  * The path to the transaction logs directory.
+  */
+  transactionLogsPath?: string;
+  /**
+  * The function used to encode keys using the shared `keyBuffer`.
+  */
+  writeKey: WriteKeyFunction;
+  /**
+  * Initializes the store with a new `NativeDatabase` instance.
+  *
+  * @param path - The path to the database.
+  * @param options - The options for the store.
+  */
+  constructor(path: string, options?: StoreOptions);
+  /**
+  * Closes the database.
+  */
+  close(): void;
+  /**
+  * Decodes a key from the database.
+  *
+  * @param key - The key to decode.
+  * @returns The decoded key.
+  */
+  decodeKey(key: Buffer): Key;
+  /**
+  * Decodes a value from the database.
+  *
+  * @param value - The value to decode.
+  * @returns The decoded value.
+  */
+  decodeValue(value: BufferWithDataView): any;
+  /**
+  * Encodes a key for the database.
+  *
+  * @param key - The key to encode.
+  * @returns The encoded key.
+  */
+  encodeKey(key: Key): BufferWithDataView;
+  /**
+  * Encodes a value for the database.
+  *
+  * @param value - The value to encode.
+  * @returns The encoded value.
+  */
+  encodeValue(value: any): BufferWithDataView | Uint8Array;
+  get(context: NativeDatabase | NativeTransaction, key: Key, alwaysCreateNewBuffer?: boolean, txnId?: number): any | undefined;
+  getCount(context: NativeDatabase | NativeTransaction, options?: RangeOptions): number;
+  getRange(context: NativeDatabase | NativeTransaction, options?: IteratorOptions & DBITransactional): ExtendedIterable<DBIteratorValue<any>>;
+  getSync(context: NativeDatabase | NativeTransaction, key: Key, alwaysCreateNewBuffer?: boolean, options?: GetOptions & DBITransactional): any | undefined;
+  /**
+  * Checks if the data method options object contains a transaction ID and
+  * returns it.
+  */
+  getTxnId(options?: DBITransactional | unknown): number | undefined;
+  /**
+  * Gets or creates a buffer that can be shared across worker threads.
+  *
+  * @param key - The key to get or create the buffer for.
+  * @param defaultBuffer - The default buffer to copy and use if the buffer
+  * does not exist.
+  * @param [options] - The options for the buffer.
+  * @param [options.callback] - A optional callback is called when `notify()`
+  * on the returned buffer is called.
+  * @returns An `ArrayBuffer` that is internally backed by a rocksdb-js
+  * managed buffer. The buffer also has `notify()` and `cancel()` methods
+  * that can be used to notify the specified `options.callback`.
+  */
+  getUserSharedBuffer(key: Key, defaultBuffer: ArrayBuffer, options?: UserSharedBufferOptions): ArrayBufferWithNotify;
+  /**
+  * Checks if a lock exists.
+  * @param key The lock key.
+  * @returns `true` if the lock exists, `false` otherwise
+  */
+  hasLock(key: Key): boolean;
+  /**
+  * Checks if the database is open.
+  *
+  * @returns `true` if the database is open, `false` otherwise.
+  */
+  isOpen(): boolean;
+  /**
+  * Lists all transaction log names.
+  *
+  * @returns an array of transaction log names.
+  */
+  listLogs(): string[];
+  /**
+  * Opens the database. This must be called before any database operations
+  * are performed.
+  */
+  open(): boolean;
+  putSync(context: NativeDatabase | NativeTransaction, key: Key, value: any, options?: PutOptions & DBITransactional): void;
+  removeSync(context: NativeDatabase | NativeTransaction, key: Key, options?: DBITransactional | undefined): void;
+  /**
+  * Attempts to acquire a lock for a given key. If the lock is available,
+  * the function returns `true` and the optional callback is never called.
+  * If the lock is not available, the function returns `false` and the
+  * callback is queued until the lock is released.
+  *
+  * @param key - The key to lock.
+  * @param onUnlocked - A callback to call when the lock is released.
+  * @returns `true` if the lock was acquired, `false` otherwise.
+  */
+  tryLock(key: Key, onUnlocked?: () => void): boolean;
+  /**
+  * Releases the lock on the given key and calls any queued `onUnlocked`
+  * callback handlers.
+  *
+  * @param key - The key to unlock.
+  */
+  unlock(key: Key): void;
+  /**
+  * Gets or creates a transaction log instance.
+  *
+  * @param context - The context to use for the transaction log.
+  * @param name - The name of the transaction log.
+  * @returns The transaction log.
+  */
+  useLog(context: NativeDatabase | NativeTransaction, name: string | number): TransactionLog;
+  /**
+  * Acquires a lock on the given key and calls the callback.
+  *
+  * @param key - The key to lock.
+  * @param callback - The callback to call when the lock is acquired.
+  * @returns A promise that resolves when the lock is acquired.
+  */
+  withLock(key: Key, callback: () => void | Promise<void>): Promise<void>;
+}
+interface GetOptions {
+  /**
+  * Whether to skip decoding the value.
+  *
+  * @default false
+  */
+  skipDecode?: boolean;
+}
+interface PutOptions {
+  append?: boolean;
+  instructedWrite?: boolean;
+  noDupData?: boolean;
+  noOverwrite?: boolean;
+}
+//#endregion
+//#region src/load-binding.d.ts
+type TransactionOptions = {
+  /**
+  * Whether to disable snapshots.
+  *
+  * @default false
+  */
+  disableSnapshot?: boolean;
+};
+type NativeTransaction = {
+  id: number;
+  new (context: NativeDatabase, options?: TransactionOptions): NativeTransaction;
+  abort(): void;
+  commit(resolve: () => void, reject: (err: Error) => void): void;
+  commitSync(): void;
+  get(keyLengthOrKeyBuffer: number | Buffer, resolve: (value: Buffer) => void, reject: (err: Error) => void): number;
+  getCount(options?: RangeOptions): number;
+  getSync(keyLengthOrKeyBuffer: number | Buffer): Buffer | number | undefined;
+  getTimestamp(): number;
+  putSync(key: Key, value: Buffer | Uint8Array, txnId?: number): void;
+  removeSync(key: Key): void;
+  setTimestamp(timestamp?: number): void;
+  useLog(name: string | number): TransactionLog;
+};
+type LogBuffer = Buffer & {
+  dataView: DataView;
+  logId: number;
+  size: number;
+};
+type TransactionLogQueryOptions = {
+  start?: number;
+  end?: number;
+  exactStart?: boolean;
+  startFromLastFlushed?: boolean;
+  readUncommitted?: boolean;
+  exclusiveStart?: boolean;
+};
+type TransactionEntry = {
+  timestamp: number;
+  data: Buffer;
+  endTxn: boolean;
+};
+type TransactionLog = {
+  new (name: string): TransactionLog;
+  addEntry(data: Buffer | Uint8Array, txnId?: number): void;
+  query(options?: TransactionLogQueryOptions): IterableIterator<TransactionEntry>;
+  _getLastFlushed(): number;
+  _getLastCommittedPosition(): Buffer;
+  _getMemoryMapOfFile(sequenceId: number): LogBuffer | undefined;
+  getLogFileSize(sequenceId?: number): number;
+  _getLastCommittedPosition(): Buffer;
+  _findPosition(timestamp: number): number;
+  _lastCommittedPosition: Float64Array;
+  _logBuffers: Map<number, WeakRef<LogBuffer>>;
+  _currentLogBuffer: LogBuffer;
+};
+type NativeDatabaseMode = "optimistic" | "pessimistic";
+type NativeDatabaseOptions = {
+  disableWAL?: boolean;
+  mode?: NativeDatabaseMode;
+  name?: string;
+  noBlockCache?: boolean;
+  parallelismThreads?: number;
+  transactionLogMaxAgeThreshold?: number;
+  transactionLogMaxSize?: number;
+  transactionLogRetentionMs?: number;
+  transactionLogsPath?: string;
+};
+type ResolveCallback<T> = (value: T) => void;
+type RejectCallback = (err: Error) => void;
+type UserSharedBufferCallback = () => void;
+type PurgeLogsOptions = {
+  destroy?: boolean;
+  name?: string;
+};
+type NativeDatabase = {
+  new (): NativeDatabase;
+  addListener(event: string, callback: (...args: any[]) => void): void;
+  clear(resolve: ResolveCallback<void>, reject: RejectCallback): void;
+  clearSync(): void;
+  close(): void;
+  drop(resolve: ResolveCallback<void>, reject: RejectCallback): void;
+  dropSync(): void;
+  flush(resolve: ResolveCallback<void>, reject: RejectCallback): void;
+  flushSync(): void;
+  notify(event: string | BufferWithDataView, args?: any[]): boolean;
+  get(keyLengthOrKeyBuffer: number | Buffer, resolve: ResolveCallback<Buffer>, reject: RejectCallback, txnId?: number): number;
+  getCount(options?: RangeOptions, txnId?: number): number;
+  getDBIntProperty(propertyName: string): number;
+  getDBProperty(propertyName: string): string;
+  getMonotonicTimestamp(): number;
+  getOldestSnapshotTimestamp(): number;
+  getSync(keyLengthOrKeyBuffer: number | Buffer, flags: number, txnId?: number): Buffer;
+  getUserSharedBuffer(key: BufferWithDataView, defaultBuffer: ArrayBuffer, callback?: UserSharedBufferCallback): ArrayBuffer;
+  hasLock(key: BufferWithDataView): boolean;
+  listeners(event: string | BufferWithDataView): number;
+  listLogs(): string[];
+  opened: boolean;
+  open(path: string, options?: NativeDatabaseOptions): void;
+  purgeLogs(options?: PurgeLogsOptions): string[];
+  putSync(key: BufferWithDataView, value: any, txnId?: number): void;
+  removeListener(event: string | BufferWithDataView, callback: () => void): boolean;
+  removeSync(key: BufferWithDataView, txnId?: number): void;
+  setDefaultKeyBuffer(buffer: Buffer | Uint8Array | null): void;
+  setDefaultValueBuffer(buffer: Buffer | Uint8Array | null): void;
+  tryLock(key: BufferWithDataView, callback?: () => void): boolean;
+  unlock(key: BufferWithDataView): void;
+  useLog(name: string): TransactionLog;
+  withLock(key: BufferWithDataView, callback: () => void | Promise<void>): Promise<void>;
+};
+type RocksDatabaseConfig = {
+  blockCacheSize?: number;
+};
+declare const constants: {
+  TRANSACTION_LOG_TOKEN: number;
+  TRANSACTION_LOG_FILE_HEADER_SIZE: number;
+  TRANSACTION_LOG_ENTRY_HEADER_SIZE: number;
+  ONLY_IF_IN_MEMORY_CACHE_FLAG: number;
+  NOT_IN_MEMORY_CACHE_FLAG: number;
+  ALWAYS_CREATE_NEW_BUFFER_FLAG: number;
+};
+declare const NativeDatabase: NativeDatabase;
+declare const NativeTransaction: NativeTransaction;
+declare const TransactionLog: TransactionLog;
+declare const shutdown: () => void;
+//#endregion
+//#region src/transaction.d.ts
+/**
+* Provides transaction level operations to a transaction callback.
+*/
+declare class Transaction extends DBI {
+  #private;
+  /**
+  * Create a new transaction.
+  *
+  * @param store - The base store interface for this transaction.
+  * @param options - The options for the transaction.
+  */
+  constructor(store: Store, options?: TransactionOptions);
+  /**
+  * Abort the transaction.
+  */
+  abort(): void;
+  /**
+  * Commit the transaction.
+  */
+  commit(): Promise<void>;
+  /**
+  * Commit the transaction synchronously.
+  */
+  commitSync(): void;
+  /**
+  * Returns the transaction start timestamp in seconds. Defaults to the time at which
+  * the transaction was created.
+  *
+  * @returns The transaction start timestamp in seconds.
+  */
+  getTimestamp(): number;
+  /**
+  * Get the transaction id.
+  */
+  get id(): number;
+  /**
+  * Set the transaction start timestamp in seconds.
+  *
+  * @param timestamp - The timestamp to set in seconds.
+  */
+  setTimestamp(timestamp?: number): void;
+}
+//#endregion
+//#region src/util.d.ts
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/dbi.d.ts
+interface RocksDBOptions {
+  /**
+  * When `true`, RocksDB will do some enhancements for prefetching the data.
+  * Defaults to `true`. Note that RocksDB defaults this to `false`.
+  */
+  adaptiveReadahead?: boolean;
+  /**
+  * When `true`, RocksDB will prefetch some data async and apply it if reads
+  * are sequential and its internal automatic prefetching. Defaults to
+  * `true`. Note that RocksDB defaults this to `false`.
+  */
+  asyncIO?: boolean;
+  /**
+  * When `true`, RocksDB will auto-tune the readahead size during scans
+  * internally based on the block cache data when block caching is enabled,
+  * an end key (e.g. upper bound) is set, and prefix is the same as the start
+  * key. Defaults to `true`.
+  */
+  autoReadaheadSize?: boolean;
+  /**
+  * When `true`, after the iterator is closed, a background job is scheduled
+  * to flush the job queue and delete obsolete files. Defaults to `true`.
+  * Note that RocksDB defaults this to `false`.
+  */
+  backgroundPurgeOnIteratorCleanup?: boolean;
+  /**
+  * When `true`, the iterator will fill the block cache. Filling the block
+  * cache is not desirable for bulk scans and could impact eviction order.
+  * Defaults to `false`. Note that RocksDB defaults this to `true`.
+  */
+  fillCache?: boolean;
+  /**
+  * The RocksDB readahead size. RocksDB does auto-readahead for iterators
+  * when there is more than two reads for a table file. The readahead
+  * starts at 8KB and doubles on every additional read up to 256KB. This
+  * option can help if most of the range scans are large and if a larger
+  * readahead than that enabled by auto-readahead is needed. Using a large
+  * readahead size (> 2MB) can typically improve the performance of forward
+  * iteration on spinning disks. Defaults to `0`.
+  */
+  readaheadSize?: number;
+  /**
+  * When `true`, creates a "tailing iterator" which is a special iterator
+  * that has a view of the complete database including newly added data and
+  * is optimized for sequential reads. This will return records that were
+  * inserted into the database after the creation of the iterator. Defaults
+  * to `false`.
+  */
+  tailing?: boolean;
+}
+interface RangeOptions extends RocksDBOptions {
+  /**
+  * The range end key, otherwise known as the "upper bound". Defaults to
+  * the last key in the database.
+  */
+  end?: Key | Uint8Array;
+  /**
+  * When `true`, the iterator will exclude the first key if it matches the start key.
+  * Defaults to `false`.
+  */
+  exclusiveStart?: boolean;
+  /**
+  * When `true`, the iterator will include the last key if it matches the end
+  * key. Defaults to `false`.
+  */
+  inclusiveEnd?: boolean;
+  /**
+  * The range start key, otherwise known as the "lower bound". Defaults to
+  * the first key in the database.
+  */
+  start?: Key | Uint8Array;
+}
+interface IteratorOptions extends RangeOptions {
+  /**
+  * A specific key to match which may result in zero, one, or many values.
+  */
+  key?: Key;
+  /**
+  * When `true`, only returns the number of values for the given query.
+  */
+  onlyCount?: boolean;
+  /**
+  * When `true`, the iterator will iterate in reverse order. Defaults to
+  * `false`.
+  */
+  reverse?: boolean;
+  /**
+  * When `true`, decodes and returns the value. When `false`, the value is
+  * omitted. Defaults to `true`.
+  */
+  values?: boolean;
+  /**
+  * When `true`, the iterator will only return the values.
+  */
+  valuesOnly?: boolean;
+}
+interface DBITransactional {
+  transaction?: Transaction;
+}
+/**
+* The base class for all database operations. This base class is shared by
+* `RocksDatabase` and `Transaction`.
+*
+* This class is not meant to be used directly.
+*/
+declare class DBI<T extends DBITransactional | unknown = unknown> {
+  #private;
+  /**
+  * The database store instance. The store instance is tied to the database
+  * instance and shared with transaction instances.
+  */
+  store: Store;
+  /**
+  * Initializes the DBI context.
+  *
+  * @param store - The store instance.
+  * @param transaction - The transaction instance.
+  */
+  constructor(store: Store, transaction?: NativeTransaction);
+  /**
+  * Adds a listener for the given key.
+  *
+  * @param event - The event name to add the listener for.
+  * @param callback - The callback to add.
+  */
+  addListener(event: string, callback: (...args: any[]) => void): this;
+  /**
+  * Retrieves the value for the given key, then returns the decoded value.
+  */
+  get(key: Key, options?: GetOptions & T): MaybePromise<any | undefined>;
+  /**
+  * Retrieves the binary data for the given key. This is just like `get()`,
+  * but bypasses the decoder.
+  *
+  * Note: Used by HDBreplication.
+  */
+  getBinary(key: Key, options?: GetOptions & T): MaybePromise<Buffer | undefined>;
+  /**
+  * Synchronously retrieves the binary data for the given key.
+  */
+  getBinarySync(key: Key, options?: GetOptions & T): Buffer | undefined;
+  /**
+  * Retrieves the binary data for the given key using a preallocated,
+  * reusable buffer. Data in the buffer is only valid until the next get
+  * operation (including cursor operations).
+  *
+  * Note: The reusable buffer slightly differs from a typical buffer:
+  * - `.length` is set to the size of the value
+  * - `.byteLength` is set to the size of the full allocated memory area for
+  *   the buffer (usually much larger).
+  */
+  getBinaryFast(key: Key, options?: GetOptions & T): MaybePromise<Buffer | undefined>;
+  /**
+  * Synchronously retrieves the binary data for the given key using a
+  * preallocated, reusable buffer. Data in the buffer is only valid until the
+  * next get operation (including cursor operations).
+  */
+  getBinaryFastSync(key: Key, options?: GetOptions & T): Buffer | undefined;
+  /**
+  * Retrieves all keys within a range.
+  */
+  getKeys(options?: IteratorOptions & T): any | undefined;
+  /**
+  * Retrieves the number of keys within a range.
+  *
+  * @param options - The range options.
+  * @returns The number of keys within the range.
+  *
+  * @example
+  * ```typescript
+  * const total = db.getKeysCount();
+  * const range = db.getKeysCount({ start: 'a', end: 'z' });
+  * ```
+  */
+  getKeysCount(options?: RangeOptions & T): number;
+  /**
+  * Retrieves a range of keys and their values.
+  *
+  * @param options - The iterator options.
+  * @returns A range iterable.
+  *
+  * @example
+  * ```typescript
+  * for (const { key, value } of db.getRange()) {
+  *   console.log({ key, value });
+  * }
+  *
+  * for (const { key, value } of db.getRange({ start: 'a', end: 'z' })) {
+  *   console.log({ key, value });
+  * }
+  * ```
+  */
+  getRange(options?: IteratorOptions & T): any | undefined;
+  /**
+  * Synchronously retrieves the value for the given key, then returns the
+  * decoded value.
+  */
+  getSync(key: Key, options?: GetOptions & T): any | undefined;
+  /**
+  * Gets the number of listeners for the given key.
+  *
+  * @param event - The event name to get the listeners for.
+  * @returns The number of listeners for the given key.
+  */
+  listeners(event: string | BufferWithDataView): number;
+  /**
+  * Notifies an event for the given key.
+  *
+  * @param event - The event name to emit the event for.
+  * @param args - The arguments to emit.
+  * @returns `true` if there were listeners, `false` otherwise.
+  */
+  notify(event: string, ...args: any[]): boolean;
+  /**
+  * Alias for `removeListener()`.
+  *
+  * @param event - The event name to remove the listener for.
+  * @param callback - The callback to remove.
+  */
+  off(event: string, callback: (...args: any[]) => void): this;
+  /**
+  * Alias for `addListener()`.
+  *
+  * @param event - The event name to add the listener for.
+  * @param callback - The callback to add.
+  */
+  on(event: string, callback: (...args: any[]) => void): this;
+  /**
+  * Adds a one-time listener, then automatically removes it.
+  *
+  * @param event - The event name to add the listener for.
+  * @param callback - The callback to add.
+  */
+  once(event: string, callback: (...args: any[]) => void): this;
+  /**
+  * Stores a value for the given key.
+  *
+  * @param key - The key to store the value for.
+  * @param value - The value to store.
+  * @param options - The put options.
+  * @returns The key and value.
+  *
+  * @example
+  * ```typescript
+  * await db.put('a', 'b');
+  * ```
+  */
+  put(key: Key, value: any, options?: PutOptions & T): Promise<void>;
+  /**
+  * Synchronously stores a value for the given key.
+  *
+  * @param key - The key to store the value for.
+  * @param value - The value to store.
+  * @param options - The put options.
+  * @returns The key and value.
+  *
+  * @example
+  * ```typescript
+  * db.putSync('a', 'b');
+  * ```
+  */
+  putSync(key: Key, value: any, options?: PutOptions & T): void;
+  /**
+  * Removes a value for the given key. If the key does not exist, it will
+  * not error.
+  *
+  * @param key - The key to remove the value for.
+  * @param options - The remove options.
+  * @returns The key and value.
+  *
+  * @example
+  * ```typescript
+  * await db.remove('a');
+  * ```
+  */
+  remove(key: Key, options?: T): Promise<void>;
+  /**
+  * Removes a value for the given key. If the key does not exist, it will
+  * not error.
+  *
+  * @param key - The key to remove the value for.
+  * @param options - The remove options.
+  * @returns The key and value.
+  *
+  * @example
+  * ```typescript
+  * db.removeSync('a');
+  * ```
+  */
+  removeSync(key: Key, options?: T): void;
+  /**
+  * Removes an event listener. You must specify the exact same callback that was
+  * used in `addListener()`.
+  *
+  * @param event - The event name to remove the listener for.
+  * @param callback - The callback to remove.
+  */
+  removeListener(event: string, callback: () => void): boolean;
+  /**
+  * Get or create a transaction log instance.
+  *
+  * @param name - The name of the transaction log.
+  * @returns The transaction log.
+  */
+  useLog(name: string | number): TransactionLog;
+}
+//#endregion
+//#region src/database.d.ts
+interface RocksDatabaseOptions extends StoreOptions {
+  /**
+  * The column family name.
+  *
+  * @default 'default'
+  */
+  name?: string;
+}
+/**
+* The main class for interacting with a RocksDB database.
+*
+* Before using this class, you must open the database first.
+*
+* @example
+* ```typescript
+* const db = RocksDatabase.open('/path/to/database');
+* await db.put('key', 'value');
+* const value = await db.get('key');
+* db.close();
+* ```
+*/
+declare class RocksDatabase extends DBI<DBITransactional> {
+  constructor(pathOrStore: string | Store, options?: RocksDatabaseOptions);
+  /**
+  * Removes all data from the database asynchronously.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.clear();
+  * ```
+  */
+  clear(): Promise<void>;
+  /**
+  * Removes all entries from the database synchronously.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * db.clearSync();
+  * ```
+  */
+  clearSync(): void;
+  /**
+  * Closes the database.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * db.close();
+  * ```
+  */
+  close(): void;
+  /**
+  * Set global database settings.
+  *
+  * @param options - The options for the database.
+  *
+  * @example
+  * ```typescript
+  * RocksDatabase.config({ blockCacheSize: 1024 * 1024 });
+  * ```
+  */
+  static config(options: RocksDatabaseConfig): void;
+  drop(): Promise<void>;
+  dropSync(): void;
+  get encoder(): Encoder | null;
+  /**
+  * Returns the current timestamp as a monotonically increasing timestamp in
+  * milliseconds represented as a decimal number.
+  *
+  * @returns The current monotonic timestamp in milliseconds.
+  */
+  getMonotonicTimestamp(): number;
+  /**
+  * Returns a number representing a unix timestamp of the oldest unreleased
+  * snapshot.
+  *
+  * @returns The oldest snapshot timestamp.
+  */
+  getOldestSnapshotTimestamp(): number;
+  /**
+  * Gets a RocksDB database property as a string.
+  *
+  * @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.levelstats').
+  * @returns The property value as a string.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * const levelStats = db.getDBProperty('rocksdb.levelstats');
+  * const stats = db.getDBProperty('rocksdb.stats');
+  * ```
+  */
+  getDBProperty(propertyName: string): string;
+  /**
+  * Gets a RocksDB database property as an integer.
+  *
+  * @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.num-blob-files').
+  * @returns The property value as a number.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * const blobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+  * const numKeys = db.getDBIntProperty('rocksdb.estimate-num-keys');
+  * ```
+  */
+  getDBIntProperty(propertyName: string): number;
+  /**
+  * Flushes the underlying database by performing a commit or clearing any buffered operations.
+  *
+  * @return {void} Does not return a value.
+  */
+  flush(): Promise<void>;
+  /**
+  * Synchronously flushes the underlying database by performing a commit or clearing any buffered operations.
+  *
+  * @return {void} Does not return a value.
+  */
+  flushSync(): void;
+  getStats(): {
+    free: {};
+    root: {};
+  };
+  /**
+  * Gets or creates a buffer that can be shared across worker threads.
+  *
+  * @param key - The key to get or create the buffer for.
+  * @param defaultBuffer - The default buffer to copy and use if the buffer
+  * does not exist.
+  * @param [options] - The options for the buffer.
+  * @param [options.callback] - A optional callback that receives
+  * key-specific events.
+  * @returns An `ArrayBuffer` that is internally backed by a shared block of
+  * memory. The buffer also has `notify()` and `cancel()` methods that can be
+  * used to notify the specified `options.callback`.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * const buffer = db.getUserSharedBuffer('foo', new ArrayBuffer(10));
+  */
+  getUserSharedBuffer(key: Key, defaultBuffer: ArrayBuffer, options?: UserSharedBufferOptions): ArrayBufferWithNotify;
+  /**
+  * Returns whether the database has a lock for the given key.
+  *
+  * @param key - The key to check.
+  * @returns `true` if the database has a lock for the given key, `false`
+  * otherwise.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * db.hasLock('foo'); // false
+  * db.tryLock('foo', () => {});
+  * db.hasLock('foo'); // true
+  * ```
+  */
+  hasLock(key: Key): boolean;
+  ifNoExists(_key: Key): Promise<void>;
+  /**
+  * Returns whether the database is open.
+  *
+  * @returns `true` if the database is open, `false` otherwise.
+  */
+  isOpen(): boolean;
+  /**
+  * Lists all transaction log names.
+  *
+  * @returns an array of transaction log names.
+  */
+  listLogs(): string[];
+  /**
+  * Sugar method for opening a database.
+  *
+  * @param pathOrStore - The filesystem path to the database or a custom store.
+  * @param options - The options for the database.
+  * @returns A new RocksDatabase instance.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * ```
+  */
+  static open(pathOrStore: string | Store, options?: RocksDatabaseOptions): RocksDatabase;
+  /**
+  * Opens the database. This function returns immediately if the database is
+  * already open.
+  *
+  * @returns A new RocksDatabase instance.
+  *
+  * @example
+  * ```typescript
+  * const db = new RocksDatabase('/path/to/database');
+  * db.open();
+  * ```
+  */
+  open(): RocksDatabase;
+  /**
+  * Returns the path to the database.
+  */
+  get path(): string;
+  /**
+  * Purges transaction logs.
+  */
+  purgeLogs(options?: PurgeLogsOptions): string[];
+  /**
+  * Executes all operations in the callback as a single transaction.
+  *
+  * @param callback - A async function that receives the transaction as an argument.
+  * @returns A promise that resolves the `callback` return value.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.transaction(async (txn) => {
+  *   await txn.put('key', 'value');
+  * });
+  * ```
+  */
+  transaction<T>(callback: (txn: Transaction) => T | PromiseLike<T>, options?: TransactionOptions): Promise<T | PromiseLike<T>>;
+  /**
+  * Executes all operations in the callback as a single transaction.
+  *
+  * @param callback - A function that receives the transaction as an
+  * argument. If the callback return promise-like value, it is awaited
+  * before committing the transaction. Otherwise, the callback is treated as
+  * synchronous.
+  * @returns The `callback` return value.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.transaction(async (txn) => {
+  *   await txn.put('key', 'value');
+  * });
+  * ```
+  */
+  transactionSync<T>(callback: (txn: Transaction) => T | PromiseLike<T>, options?: TransactionOptions): T | PromiseLike<T> | undefined;
+  /**
+  * Attempts to acquire a lock for a given key. If the lock is available,
+  * the function returns `true` and the optional callback is never called.
+  * If the lock is not available, the function returns `false` and the
+  * callback is queued until the lock is released.
+  *
+  * @param key - The key to lock.
+  * @param onUnlocked - A callback to call when the lock is released.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * db.tryLock('foo', () => {
+  *   console.log('lock acquired');
+  * });
+  * ```
+  * @returns `true` if the lock was acquired, `false` otherwise.
+  */
+  tryLock(key: Key, onUnlocked?: () => void): boolean;
+  /**
+  * Releases the lock on the given key and calls any queued `onUnlocked`
+  * callback handlers.
+  *
+  * @param key - The key to unlock.
+  * @returns `true` if the lock was released or `false` if the lock did not
+  * exist.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * db.tryLock('foo', () => {});
+  * db.unlock('foo'); // returns `true`
+  * db.unlock('foo'); // already unlocked, returns `false`
+  * ```
+  */
+  unlock(key: Key): void;
+  /**
+  * Excecutes a function using a thread-safe lock to ensure mutual
+  * exclusion.
+  *
+  * @param callback - A callback to call when the lock is acquired.
+  * @returns A promise that resolves when the lock is acquired.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.withLock(async (waited) => {
+  *   console.log('lock acquired', waited);
+  * });
+  * ```
+  */
+  withLock(key: Key, callback: () => void | Promise<void>): Promise<void> | undefined;
+}
+//#endregion
+//#region src/parse-transaction-log.d.ts
+interface LogEntry {
+  data: Buffer;
+  flags: number;
+  length: number;
+  timestamp?: number;
+}
+interface TransactionLog$1 {
+  entries: LogEntry[];
+  timestamp: number;
+  size: number;
+  version: number;
+}
+/**
+* Loads an entire transaction log file into memory.
+* @param path - The path to the transaction log file.
+* @returns The transaction log.
+*/
+declare function parseTransactionLog(path: string): TransactionLog$1;
+//#endregion
+//#region src/index.d.ts
+declare const versions: {
+  rocksdb: string;
+  "rocksdb-js": string;
+};
+//#endregion
+export { type Context, DBIterator, type Key, RocksDatabase, type RocksDatabaseOptions, Store, Transaction, type TransactionEntry, TransactionLog, constants, parseTransactionLog, shutdown, versions };
+//# sourceMappingURL=index.d.mts.map