@slatedb/uniffi 0.12.0

package/slatedb.d.ts

@@ -0,0 +1,1393 @@
+import { UniffiObjectBase } from "./runtime/objects.js";
+
+
+
+export interface ComponentMetadata {
+  namespace: string;
+  packageName: string;
+  cdylibName: string;
+  nodeEngine: string;
+  bundledPrebuilds: boolean;
+  manualLoad: boolean;
+}
+
+export declare const componentMetadata: Readonly<ComponentMetadata>;
+
+export { ffiMetadata } from "./slatedb-ffi.js";
+
+
+/**
+ * Options for an explicit flush request.
+ */
+export interface FlushOptions {
+  /**
+   * Which storage layer should be flushed.
+   */
+  "flush_type": FlushType;
+}
+
+/**
+ * Options applied to a merge operation.
+ */
+export interface MergeOptions {
+  /**
+   * TTL policy for the inserted merge operand.
+   */
+  "ttl": Ttl;
+}
+
+/**
+ * Options applied to a put operation.
+ */
+export interface PutOptions {
+  /**
+   * TTL policy for the inserted value.
+   */
+  "ttl": Ttl;
+}
+
+/**
+ * Options that control a point read.
+ */
+export interface ReadOptions {
+  /**
+   * Minimum durability level a returned row must satisfy.
+   */
+  "durability_filter": DurabilityLevel;
+  /**
+   * Whether uncommitted dirty data may be returned.
+   */
+  "dirty": boolean;
+  /**
+   * Whether fetched blocks should be inserted into the block cache.
+   */
+  "cache_blocks": boolean;
+}
+
+/**
+ * Options for opening a [`crate::DbReader`].
+ */
+export interface ReaderOptions {
+  /**
+   * How often the reader polls for new manifests and WAL data, in milliseconds.
+   */
+  "manifest_poll_interval_ms": bigint | number;
+  /**
+   * Lifetime of an internally managed checkpoint, in milliseconds.
+   */
+  "checkpoint_lifetime_ms": bigint | number;
+  /**
+   * Maximum size of one in-memory table used while replaying WAL data.
+   */
+  "max_memtable_bytes": bigint | number;
+  /**
+   * Whether WAL replay should be skipped entirely.
+   */
+  "skip_wal_replay": boolean;
+}
+
+/**
+ * Options that control range scans and prefix scans.
+ */
+export interface ScanOptions {
+  /**
+   * Minimum durability level a returned row must satisfy.
+   */
+  "durability_filter": DurabilityLevel;
+  /**
+   * Whether uncommitted dirty data may be returned.
+   */
+  "dirty": boolean;
+  /**
+   * Number of bytes to read ahead while scanning.
+   */
+  "read_ahead_bytes": bigint | number;
+  /**
+   * Whether fetched blocks should be inserted into the block cache.
+   */
+  "cache_blocks": boolean;
+  /**
+   * Maximum number of concurrent fetch tasks used by the scan.
+   */
+  "max_fetch_tasks": bigint | number;
+  /**
+   * The iteration order for the scan. Defaults to ascending when not set.
+   */
+  "order": IterationOrder | undefined;
+}
+
+/**
+ * Options that control durability behavior for writes and commits.
+ */
+export interface WriteOptions {
+  /**
+   * Whether the call waits for the write to become durable before returning.
+   */
+  "await_durable": boolean;
+}
+
+/**
+ * A single log event forwarded to a foreign callback.
+ */
+export interface LogRecord {
+  /**
+   * Event severity.
+   */
+  "level": LogLevel;
+  /**
+   * Logging target or explicit `log.target` field.
+   */
+  "target": string;
+  /**
+   * Rendered log message.
+   */
+  "message": string;
+  /**
+   * Rust module path, when available.
+   */
+  "module_path": string | undefined;
+  /**
+   * Source file path, when available.
+   */
+  "file": string | undefined;
+  /**
+   * Source line number, when available.
+   */
+  "line": number | undefined;
+}
+
+/**
+ * Histogram payload captured in a metric snapshot.
+ */
+export interface HistogramMetricValue {
+  /**
+   * Total number of recorded observations.
+   */
+  "count": bigint | number;
+  /**
+   * Sum of all observed values.
+   */
+  "sum": number;
+  /**
+   * Minimum observed value.
+   */
+  "min": number;
+  /**
+   * Maximum observed value.
+   */
+  "max": number;
+  /**
+   * Histogram bucket boundaries.
+   */
+  "boundaries": Array<number>;
+  /**
+   * Number of observations in each bucket.
+   */
+  "bucket_counts": Array<bigint | number>;
+}
+
+/**
+ * One metric from a [`DefaultMetricsRecorder`] snapshot.
+ */
+export interface Metric {
+  /**
+   * Dotted metric name.
+   */
+  "name": string;
+  /**
+   * Canonical label set for the metric instance.
+   */
+  "labels": Array<MetricLabel>;
+  /**
+   * Human-readable description.
+   */
+  "description": string;
+  /**
+   * Current metric value.
+   */
+  "value": MetricValue;
+}
+
+/**
+ * Key-value label attached to a metric.
+ */
+export interface MetricLabel {
+  /**
+   * Label key.
+   */
+  "key": string;
+  /**
+   * Label value.
+   */
+  "value": string;
+}
+
+/**
+ * Snapshot of the current database lifecycle and durability state.
+ */
+export interface DbStatus {
+  /**
+   * Highest durable sequence number observed by this handle.
+   */
+  "durable_seq": bigint | number;
+  /**
+   * Present once the handle has been closed.
+   */
+  "close_reason": CloseReason | undefined;
+}
+
+/**
+ * A half-open or closed byte-key range used by scan APIs.
+ */
+export interface KeyRange {
+  /**
+   * Inclusive or exclusive lower bound. `None` means unbounded.
+   */
+  "start": Uint8Array | undefined;
+  /**
+   * Whether `start` is inclusive when present.
+   */
+  "start_inclusive": boolean;
+  /**
+   * Inclusive or exclusive upper bound. `None` means unbounded.
+   */
+  "end": Uint8Array | undefined;
+  /**
+   * Whether `end` is inclusive when present.
+   */
+  "end_inclusive": boolean;
+}
+
+/**
+ * A key/value pair together with the row version metadata that produced it.
+ */
+export interface KeyValue {
+  /**
+   * Row key.
+   */
+  "key": Uint8Array;
+  /**
+   * Row value bytes.
+   */
+  "value": Uint8Array;
+  /**
+   * Sequence number of the row version.
+   */
+  "seq": bigint | number;
+  /**
+   * Creation timestamp of the row version.
+   */
+  "create_ts": bigint | number;
+  /**
+   * Expiration timestamp, if the row has a TTL.
+   */
+  "expire_ts": bigint | number | undefined;
+}
+
+/**
+ * A raw row entry returned from WAL inspection.
+ */
+export interface RowEntry {
+  /**
+   * Encoded row kind.
+   */
+  "kind": RowEntryKind;
+  /**
+   * Row key.
+   */
+  "key": Uint8Array;
+  /**
+   * Row value for value and merge entries. `None` for tombstones.
+   */
+  "value": Uint8Array | undefined;
+  /**
+   * Sequence number of the entry.
+   */
+  "seq": bigint | number;
+  /**
+   * Creation timestamp if present in the WAL entry.
+   */
+  "create_ts": bigint | number | undefined;
+  /**
+   * Expiration timestamp if present in the WAL entry.
+   */
+  "expire_ts": bigint | number | undefined;
+}
+
+/**
+ * Metadata returned by a successful write.
+ */
+export interface WriteHandle {
+  /**
+   * Sequence number assigned to the write.
+   */
+  "seqnum": bigint | number;
+  /**
+   * Creation timestamp assigned to the write.
+   */
+  "create_ts": bigint | number;
+}
+
+/**
+ * Metadata describing a WAL file in object storage.
+ */
+export interface WalFileMetadata {
+  /**
+   * Last-modified timestamp seconds component.
+   */
+  "last_modified_seconds": bigint | number;
+  /**
+   * Last-modified timestamp nanoseconds component.
+   */
+  "last_modified_nanos": number;
+  /**
+   * File size in bytes.
+   */
+  "size_bytes": bigint | number;
+  /**
+   * Object-store location of the file.
+   */
+  "location": string;
+}
+
+/**
+ * Minimum durability level required for data returned by reads and scans.
+ */
+export declare const DurabilityLevel: Readonly<{
+  /**
+   * Return only data that has been flushed to remote object storage.
+   */
+  "Remote": "Remote";
+  /**
+   * Return both remote data and newer in-memory data.
+   */
+  "Memory": "Memory";
+}>;
+/**
+ * Minimum durability level required for data returned by reads and scans.
+ */
+export type DurabilityLevel = (typeof DurabilityLevel)[keyof typeof DurabilityLevel];
+
+/**
+ * Storage layer targeted by an explicit flush.
+ */
+export declare const FlushType: Readonly<{
+  /**
+   * Flush the active memtable and any immutable memtables to object storage.
+   */
+  "MemTable": "MemTable";
+  /**
+   * Flush the active WAL and any immutable WAL segments to object storage.
+   */
+  "Wal": "Wal";
+}>;
+/**
+ * Storage layer targeted by an explicit flush.
+ */
+export type FlushType = (typeof FlushType)[keyof typeof FlushType];
+
+/**
+ * Isolation level used when starting a transaction.
+ */
+export declare const IsolationLevel: Readonly<{
+  /**
+   * Reads see a stable snapshot without full serializable conflict checking.
+   */
+  "Snapshot": "Snapshot";
+  /**
+   * Reads see a stable snapshot with serializable conflict detection.
+   */
+  "SerializableSnapshot": "SerializableSnapshot";
+}>;
+/**
+ * Isolation level used when starting a transaction.
+ */
+export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];
+
+/**
+ * The iteration order for a scan.
+ */
+export declare const IterationOrder: Readonly<{
+  "Ascending": "Ascending";
+  "Descending": "Descending";
+}>;
+/**
+ * The iteration order for a scan.
+ */
+export type IterationOrder = (typeof IterationOrder)[keyof typeof IterationOrder];
+
+/**
+ * Block size used for newly written SSTable blocks.
+ */
+export declare const SstBlockSize: Readonly<{
+  /**
+   * 1 KiB blocks.
+   */
+  "Block1Kib": "Block1Kib";
+  /**
+   * 2 KiB blocks.
+   */
+  "Block2Kib": "Block2Kib";
+  /**
+   * 4 KiB blocks.
+   */
+  "Block4Kib": "Block4Kib";
+  /**
+   * 8 KiB blocks.
+   */
+  "Block8Kib": "Block8Kib";
+  /**
+   * 16 KiB blocks.
+   */
+  "Block16Kib": "Block16Kib";
+  /**
+   * 32 KiB blocks.
+   */
+  "Block32Kib": "Block32Kib";
+  /**
+   * 64 KiB blocks.
+   */
+  "Block64Kib": "Block64Kib";
+}>;
+/**
+ * Block size used for newly written SSTable blocks.
+ */
+export type SstBlockSize = (typeof SstBlockSize)[keyof typeof SstBlockSize];
+
+/**
+ * Reason a database or reader reports itself as closed.
+ */
+export declare const CloseReason: Readonly<{
+  /**
+   * Closed cleanly by the caller.
+   */
+  "Clean": "Clean";
+  /**
+   * Closed because another writer fenced this instance.
+   */
+  "Fenced": "Fenced";
+  /**
+   * Closed because of a panic in a background task.
+   */
+  "Panic": "Panic";
+  /**
+   * Closed for a reason not modeled explicitly by this binding.
+   */
+  "Unknown": "Unknown";
+}>;
+/**
+ * Reason a database or reader reports itself as closed.
+ */
+export type CloseReason = (typeof CloseReason)[keyof typeof CloseReason];
+
+/**
+ * Log level used by [`init_logging`].
+ */
+export declare const LogLevel: Readonly<{
+  /**
+   * Disable logging.
+   */
+  "Off": "Off";
+  /**
+   * Error-level logs only.
+   */
+  "Error": "Error";
+  /**
+   * Warning and error logs.
+   */
+  "Warn": "Warn";
+  /**
+   * Info, warning, and error logs.
+   */
+  "Info": "Info";
+  /**
+   * Debug, info, warning, and error logs.
+   */
+  "Debug": "Debug";
+  /**
+   * Trace and all higher-severity logs.
+   */
+  "Trace": "Trace";
+}>;
+/**
+ * Log level used by [`init_logging`].
+ */
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+
+/**
+ * Kind of row entry stored in WAL iteration results.
+ */
+export declare const RowEntryKind: Readonly<{
+  /**
+   * A regular value row.
+   */
+  "Value": "Value";
+  /**
+   * A delete tombstone.
+   */
+  "Tombstone": "Tombstone";
+  /**
+   * A merge operand row.
+   */
+  "Merge": "Merge";
+}>;
+/**
+ * Kind of row entry stored in WAL iteration results.
+ */
+export type RowEntryKind = (typeof RowEntryKind)[keyof typeof RowEntryKind];
+
+/**
+ * Use the database default TTL.
+ */
+export interface TtlDefault {
+  tag: "Default";
+}
+
+/**
+ * Store the value without expiration.
+ */
+export interface TtlNoExpiry {
+  tag: "NoExpiry";
+}
+
+/**
+ * Expire the value after the given number of clock ticks.
+ */
+export interface TtlExpireAfterTicks {
+  tag: "ExpireAfterTicks";
+  "": bigint | number;
+}
+
+/**
+ * Expire the value at the given absolute timestamp (clock ticks).
+ */
+export interface TtlExpireAt {
+  tag: "ExpireAt";
+  "": bigint | number;
+}
+
+/**
+ * Time-to-live policy applied to an inserted value or merge operand.
+ */
+export type Ttl = TtlDefault | TtlNoExpiry | TtlExpireAfterTicks | TtlExpireAt;
+/**
+ * Time-to-live policy applied to an inserted value or merge operand.
+ */
+export declare const Ttl: Readonly<{
+  /**
+   * Use the database default TTL.
+   */
+  Default(): TtlDefault;
+  /**
+   * Store the value without expiration.
+   */
+  NoExpiry(): TtlNoExpiry;
+  /**
+   * Expire the value after the given number of clock ticks.
+   */
+  ExpireAfterTicks(_: bigint | number): TtlExpireAfterTicks;
+  /**
+   * Expire the value at the given absolute timestamp (clock ticks).
+   */
+  ExpireAt(_: bigint | number): TtlExpireAt;
+}>;
+
+/**
+ * Monotonic counter value.
+ */
+export interface MetricValueCounter {
+  tag: "Counter";
+  "": bigint | number;
+}
+
+/**
+ * Gauge value.
+ */
+export interface MetricValueGauge {
+  tag: "Gauge";
+  "": bigint | number;
+}
+
+/**
+ * Up/down counter value.
+ */
+export interface MetricValueUpDownCounter {
+  tag: "UpDownCounter";
+  "": bigint | number;
+}
+
+/**
+ * Histogram summary and buckets.
+ */
+export interface MetricValueHistogram {
+  tag: "Histogram";
+  "": HistogramMetricValue;
+}
+
+/**
+ * Value stored in a metric snapshot.
+ */
+export type MetricValue = MetricValueCounter | MetricValueGauge | MetricValueUpDownCounter | MetricValueHistogram;
+/**
+ * Value stored in a metric snapshot.
+ */
+export declare const MetricValue: Readonly<{
+  /**
+   * Monotonic counter value.
+   */
+  Counter(_: bigint | number): MetricValueCounter;
+  /**
+   * Gauge value.
+   */
+  Gauge(_: bigint | number): MetricValueGauge;
+  /**
+   * Up/down counter value.
+   */
+  UpDownCounter(_: bigint | number): MetricValueUpDownCounter;
+  /**
+   * Histogram summary and buckets.
+   */
+  Histogram(_: HistogramMetricValue): MetricValueHistogram;
+}>;
+
+/**
+ * Error type returned by the UniFFI bindings.
+ */
+export declare class Error extends globalThis.Error {
+  readonly tag: string;
+  protected constructor(tag: string, message?: string);
+}
+
+/**
+ * Transaction-specific failure.
+ */
+export declare class ErrorTransaction extends Error {
+  readonly tag: "Transaction";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Operation attempted on a closed handle.
+ */
+export declare class ErrorClosed extends Error {
+  readonly tag: "Closed";
+  /**
+   * Reported reason the handle is closed.
+   */
+  readonly "reason": CloseReason;
+  /**
+   * Human-readable error message.
+   */
+  readonly "message": string;
+  constructor(reason: CloseReason, message: string);
+}
+
+/**
+ * Temporary unavailability, such as an unavailable dependency.
+ */
+export declare class ErrorUnavailable extends Error {
+  readonly tag: "Unavailable";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Invalid input or invalid API usage.
+ */
+export declare class ErrorInvalid extends Error {
+  readonly tag: "Invalid";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Corrupt, missing, or otherwise invalid data was encountered.
+ */
+export declare class ErrorData extends Error {
+  readonly tag: "Data";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Internal failure inside SlateDB or the binding layer.
+ */
+export declare class ErrorInternal extends Error {
+  readonly tag: "Internal";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Error returned by a foreign [`crate::MergeOperator`] implementation.
+ */
+export declare class MergeOperatorCallbackError extends globalThis.Error {
+  readonly tag: string;
+  protected constructor(tag: string, message?: string);
+}
+
+/**
+ * The merge callback failed with an application-defined message.
+ */
+export declare class MergeOperatorCallbackErrorFailed extends MergeOperatorCallbackError {
+  readonly tag: "Failed";
+  readonly "message": string;
+  constructor(message: string);
+}
+
+/**
+ * Callback invoked for each emitted log record.
+ */
+export interface LogCallback {
+  /**
+   * Handles one log record.
+   */
+  log(record: LogRecord): void;
+}
+
+/**
+ * Application-provided merge operator used by merge-enabled databases.
+ */
+export interface MergeOperator {
+  /**
+   * Combines an existing value and a new merge operand into the next value.
+   *
+   * `existing_value` is `None` when the key has no visible base value.
+   */
+  merge(key: Uint8Array, existing_value: Uint8Array | undefined, operand: Uint8Array): Uint8Array;
+}
+
+/**
+ * Handle for a monotonic counter metric.
+ */
+export interface Counter {
+  /**
+   * Adds `value` to the counter.
+   */
+  increment(value: bigint | number): void;
+}
+
+/**
+ * Handle for a gauge metric.
+ */
+export interface Gauge {
+  /**
+   * Sets the gauge to `value`.
+   */
+  set(value: bigint | number): void;
+}
+
+/**
+ * Handle for a histogram metric.
+ */
+export interface Histogram {
+  /**
+   * Records `value` in the histogram.
+   */
+  record(value: number): void;
+}
+
+/**
+ * Application-defined metrics recorder used to publish SlateDB metrics.
+ */
+export interface MetricsRecorder {
+  /**
+   * Registers a monotonically increasing counter.
+   */
+  register_counter(name: string, description: string, labels: Array<MetricLabel>): Counter;
+  /**
+   * Registers a gauge.
+   */
+  register_gauge(name: string, description: string, labels: Array<MetricLabel>): Gauge;
+  /**
+   * Registers an up/down counter.
+   */
+  register_up_down_counter(name: string, description: string, labels: Array<MetricLabel>): UpDownCounter;
+  /**
+   * Registers a histogram with explicit bucket boundaries.
+   */
+  register_histogram(name: string, description: string, labels: Array<MetricLabel>, boundaries: Array<number>): Histogram;
+}
+
+/**
+ * Handle for an up/down counter metric.
+ */
+export interface UpDownCounter {
+  /**
+   * Adds `value` to the counter.
+   */
+  increment(value: bigint | number): void;
+}
+
+/**
+ * Installs SlateDB logging exactly once for the current process.
+ *
+ * If `callback` is provided, log records are forwarded to it. Otherwise logs
+ * are written to standard error using the default tracing formatter.
+ */
+export declare function init_logging(level: LogLevel, callback: LogCallback | undefined): void;
+
+/**
+ * Builder for opening a writable [`crate::Db`].
+ *
+ * Builders are single-use: calling [`DbBuilder::build`] consumes the builder.
+ */
+export declare class DbBuilder extends UniffiObjectBase {
+  /**
+   * Creates a new database builder for `path` in `object_store`.
+   */
+  constructor(path: string, object_store: ObjectStore);
+  /**
+   * Opens the database and consumes this builder.
+   */
+  build(): Promise<Db>;
+  /**
+   * Disables the SST block and metadata cache.
+   */
+  with_db_cache_disabled(): void;
+  /**
+   * Installs an application-defined merge operator.
+   */
+  with_merge_operator(merge_operator: MergeOperator): void;
+  /**
+   * Installs an application-defined metrics recorder.
+   */
+  with_metrics_recorder(metrics_recorder: MetricsRecorder): void;
+  /**
+   * Sets the seed used for SlateDB's internal random number generation.
+   */
+  with_seed(seed: bigint | number): void;
+  /**
+   * Applies a [`crate::Settings`] object to the builder.
+   */
+  with_settings(settings: Settings): void;
+  /**
+   * Sets the SSTable block size used for newly written tables.
+   */
+  with_sst_block_size(sst_block_size: SstBlockSize): void;
+  /**
+   * Uses a separate object store for WAL files.
+   */
+  with_wal_object_store(wal_object_store: ObjectStore): void;
+}
+
+/**
+ * Builder for opening a read-only [`crate::DbReader`].
+ *
+ * Builders are single-use: calling [`DbReaderBuilder::build`] consumes the builder.
+ */
+export declare class DbReaderBuilder extends UniffiObjectBase {
+  /**
+   * Creates a new reader builder for `path` in `object_store`.
+   */
+  constructor(path: string, object_store: ObjectStore);
+  /**
+   * Opens the reader and consumes this builder.
+   */
+  build(): Promise<DbReader>;
+  /**
+   * Pins the reader to an existing checkpoint UUID string.
+   */
+  with_checkpoint_id(checkpoint_id: string): void;
+  /**
+   * Installs an application-defined merge operator used while reading merge rows.
+   */
+  with_merge_operator(merge_operator: MergeOperator): void;
+  /**
+   * Installs an application-defined metrics recorder.
+   */
+  with_metrics_recorder(metrics_recorder: MetricsRecorder): void;
+  /**
+   * Applies custom reader options.
+   */
+  with_options(options: ReaderOptions): void;
+  /**
+   * Uses a separate object store for WAL files.
+   */
+  with_wal_object_store(wal_object_store: ObjectStore): void;
+}
+
+/**
+ * A writable SlateDB handle.
+ */
+export declare class Db extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Starts a transaction at the requested isolation level.
+   */
+  begin(isolation_level: IsolationLevel): Promise<DbTransaction>;
+  /**
+   * Deletes `key` and returns metadata for the write.
+   */
+  delete(key: Uint8Array): Promise<WriteHandle>;
+  /**
+   * Deletes `key` using custom write options.
+   */
+  delete_with_options(key: Uint8Array, options: WriteOptions): Promise<WriteHandle>;
+  /**
+   * Flushes the default storage layer.
+   */
+  flush(): Promise<void>;
+  /**
+   * Flushes according to the provided flush options.
+   */
+  flush_with_options(options: FlushOptions): Promise<void>;
+  /**
+   * Reads the current value for `key`.
+   */
+  get(key: Uint8Array): Promise<Uint8Array | undefined>;
+  /**
+   * Reads the current row version for `key`, including metadata.
+   */
+  get_key_value(key: Uint8Array): Promise<KeyValue | undefined>;
+  /**
+   * Reads the current row version for `key` using custom read options.
+   */
+  get_key_value_with_options(key: Uint8Array, options: ReadOptions): Promise<KeyValue | undefined>;
+  /**
+   * Reads the current value for `key` using custom read options.
+   */
+  get_with_options(key: Uint8Array, options: ReadOptions): Promise<Uint8Array | undefined>;
+  /**
+   * Appends a merge operand for `key` and returns metadata for the write.
+   */
+  merge(key: Uint8Array, operand: Uint8Array): Promise<WriteHandle>;
+  /**
+   * Appends a merge operand using custom merge and write options.
+   */
+  merge_with_options(key: Uint8Array, operand: Uint8Array, merge_options: MergeOptions, write_options: WriteOptions): Promise<WriteHandle>;
+  /**
+   * Inserts or overwrites a value and returns metadata for the write.
+   *
+   * Keys must be non-empty and at most `u16::MAX` bytes. Values must be at
+   * most `u32::MAX` bytes.
+   */
+  put(key: Uint8Array, value: Uint8Array): Promise<WriteHandle>;
+  /**
+   * Inserts or overwrites a value using custom put and write options.
+   */
+  put_with_options(key: Uint8Array, value: Uint8Array, put_options: PutOptions, write_options: WriteOptions): Promise<WriteHandle>;
+  /**
+   * Scans rows inside `range`.
+   */
+  scan(range: KeyRange): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix`.
+   */
+  scan_prefix(prefix: Uint8Array): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` using custom scan options.
+   */
+  scan_prefix_with_options(prefix: Uint8Array, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Scans rows inside `range` using custom scan options.
+   */
+  scan_with_options(range: KeyRange, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Flushes outstanding work and closes the database.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Creates a read-only snapshot representing a consistent point in time.
+   */
+  snapshot(): Promise<DbSnapshot>;
+  /**
+   * Returns the latest database status snapshot.
+   */
+  status(): DbStatus;
+  /**
+   * Applies all operations in `batch` atomically.
+   *
+   * The provided batch is consumed and cannot be reused afterwards.
+   */
+  write(batch: WriteBatch): Promise<WriteHandle>;
+  /**
+   * Applies all operations in `batch` atomically using custom write options.
+   *
+   * The provided batch is consumed and cannot be reused afterwards.
+   */
+  write_with_options(batch: WriteBatch, options: WriteOptions): Promise<WriteHandle>;
+}
+
+/**
+ * Read-only database handle opened by [`crate::DbReaderBuilder`].
+ */
+export declare class DbReader extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Reads the current value for `key`.
+   */
+  get(key: Uint8Array): Promise<Uint8Array | undefined>;
+  /**
+   * Reads the current value for `key` using custom read options.
+   */
+  get_with_options(key: Uint8Array, options: ReadOptions): Promise<Uint8Array | undefined>;
+  /**
+   * Scans rows inside `range`.
+   */
+  scan(range: KeyRange): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix`.
+   */
+  scan_prefix(prefix: Uint8Array): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` using custom scan options.
+   */
+  scan_prefix_with_options(prefix: Uint8Array, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Scans rows inside `range` using custom scan options.
+   */
+  scan_with_options(range: KeyRange, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Closes the reader.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Returns the latest reader status snapshot.
+   */
+  status(): DbStatus;
+}
+
+/**
+ * Read-only snapshot representing a consistent view of the database.
+ */
+export declare class DbSnapshot extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Reads the value visible in this snapshot for `key`.
+   */
+  get(key: Uint8Array): Promise<Uint8Array | undefined>;
+  /**
+   * Reads the row version visible in this snapshot for `key`.
+   */
+  get_key_value(key: Uint8Array): Promise<KeyValue | undefined>;
+  /**
+   * Reads the row version visible in this snapshot for `key` using custom read options.
+   */
+  get_key_value_with_options(key: Uint8Array, options: ReadOptions): Promise<KeyValue | undefined>;
+  /**
+   * Reads the value visible in this snapshot for `key` using custom read options.
+   */
+  get_with_options(key: Uint8Array, options: ReadOptions): Promise<Uint8Array | undefined>;
+  /**
+   * Scans rows inside `range` as of this snapshot.
+   */
+  scan(range: KeyRange): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` as of this snapshot.
+   */
+  scan_prefix(prefix: Uint8Array): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` as of this snapshot using custom options.
+   */
+  scan_prefix_with_options(prefix: Uint8Array, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Scans rows inside `range` as of this snapshot using custom scan options.
+   */
+  scan_with_options(range: KeyRange, options: ScanOptions): Promise<DbIterator>;
+}
+
+/**
+ * Transaction handle returned by [`crate::Db::begin`].
+ *
+ * A transaction becomes unusable after `commit`, `commit_with_options`, or
+ * `rollback`.
+ */
+export declare class DbTransaction extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Commits the transaction.
+   *
+   * Returns `None` when the transaction performed no writes.
+   */
+  commit(): Promise<WriteHandle | undefined>;
+  /**
+   * Commits the transaction using custom write options.
+   *
+   * Returns `None` when the transaction performed no writes.
+   */
+  commit_with_options(options: WriteOptions): Promise<WriteHandle | undefined>;
+  /**
+   * Buffers a delete inside the transaction.
+   */
+  delete(key: Uint8Array): Promise<void>;
+  /**
+   * Reads the value visible to this transaction for `key`.
+   */
+  get(key: Uint8Array): Promise<Uint8Array | undefined>;
+  /**
+   * Reads the row version visible to this transaction for `key`.
+   */
+  get_key_value(key: Uint8Array): Promise<KeyValue | undefined>;
+  /**
+   * Reads the row version visible to this transaction for `key` using custom options.
+   */
+  get_key_value_with_options(key: Uint8Array, options: ReadOptions): Promise<KeyValue | undefined>;
+  /**
+   * Reads the value visible to this transaction for `key` using custom read options.
+   */
+  get_with_options(key: Uint8Array, options: ReadOptions): Promise<Uint8Array | undefined>;
+  /**
+   * Returns the transaction identifier as a UUID string.
+   */
+  id(): string;
+  /**
+   * Marks keys as read for conflict detection.
+   */
+  mark_read(keys: Array<Uint8Array>): Promise<void>;
+  /**
+   * Buffers a merge operand inside the transaction.
+   */
+  merge(key: Uint8Array, operand: Uint8Array): Promise<void>;
+  /**
+   * Buffers a merge operand inside the transaction using custom merge options.
+   */
+  merge_with_options(key: Uint8Array, operand: Uint8Array, options: MergeOptions): Promise<void>;
+  /**
+   * Buffers a put inside the transaction.
+   */
+  put(key: Uint8Array, value: Uint8Array): Promise<void>;
+  /**
+   * Buffers a put inside the transaction using custom put options.
+   */
+  put_with_options(key: Uint8Array, value: Uint8Array, options: PutOptions): Promise<void>;
+  /**
+   * Rolls back the transaction and marks it completed.
+   */
+  rollback(): Promise<void>;
+  /**
+   * Scans rows inside `range` as visible to this transaction.
+   */
+  scan(range: KeyRange): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` as visible to this transaction.
+   */
+  scan_prefix(prefix: Uint8Array): Promise<DbIterator>;
+  /**
+   * Scans rows whose keys start with `prefix` as visible to this transaction using custom options.
+   */
+  scan_prefix_with_options(prefix: Uint8Array, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Scans rows inside `range` as visible to this transaction using custom options.
+   */
+  scan_with_options(range: KeyRange, options: ScanOptions): Promise<DbIterator>;
+  /**
+   * Returns the sequence number assigned when the transaction started.
+   */
+  seqnum(): bigint | number;
+  /**
+   * Excludes written keys from transaction conflict detection.
+   */
+  unmark_write(keys: Array<Uint8Array>): Promise<void>;
+}
+
+/**
+ * Async iterator returned by scan APIs.
+ */
+export declare class DbIterator extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Returns the next key/value pair from the iterator.
+   */
+  next(): Promise<KeyValue | undefined>;
+  /**
+   * Seeks the iterator to the first entry at or after `key`.
+   */
+  seek(key: Uint8Array): Promise<void>;
+}
+
+/**
+ * Built-in atomic-backed metrics recorder with snapshot access.
+ */
+export declare class DefaultMetricsRecorder extends UniffiObjectBase {
+  /**
+   * Creates an empty default metrics recorder.
+   */
+  constructor();
+  /**
+   * Returns the metric matching `name` and the exact label set, if present.
+   */
+  metric_by_name_and_labels(name: string, labels: Array<MetricLabel>): Metric | undefined;
+  /**
+   * Returns every metric with the requested name.
+   */
+  metrics_by_name(name: string): Array<Metric>;
+  register_counter(name: string, description: string, labels: Array<MetricLabel>): Counter;
+  register_gauge(name: string, description: string, labels: Array<MetricLabel>): Gauge;
+  register_histogram(name: string, description: string, labels: Array<MetricLabel>, boundaries: Array<number>): Histogram;
+  register_up_down_counter(name: string, description: string, labels: Array<MetricLabel>): UpDownCounter;
+  /**
+   * Returns a point-in-time snapshot of every registered metric.
+   */
+  snapshot(): Array<Metric>;
+}
+
+/**
+ * Object store handle used when opening databases, readers, and WAL readers.
+ */
+export declare class ObjectStore extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Builds an object store from environment configuration.
+   *
+   * When `env_file` is provided, environment variables are loaded from that
+   * file before constructing the store.
+   */
+  static from_env(env_file: string | undefined): ObjectStore;
+  /**
+   * Resolves an object store from a URL understood by SlateDB.
+   */
+  static resolve(url: string): ObjectStore;
+}
+
+/**
+ * Mutable database settings object used to configure a [`crate::DbBuilder`].
+ */
+export declare class Settings extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Creates a settings object populated with SlateDB defaults.
+   */
+  static default(): Settings;
+  /**
+   * Loads settings from environment variables using `prefix`.
+   */
+  static from_env(prefix: string): Settings;
+  /**
+   * Loads settings from environment variables, falling back to `default_settings`.
+   */
+  static from_env_with_default(prefix: string, default_settings: Settings): Settings;
+  /**
+   * Loads settings from a JSON, TOML, or YAML file based on its extension.
+   */
+  static from_file(path: string): Settings;
+  /**
+   * Parses settings from a JSON string.
+   */
+  static from_json_string(json: string): Settings;
+  /**
+   * Loads settings from SlateDB's default file and environment lookup order.
+   */
+  static load(): Settings;
+  /**
+   * Sets a settings field by dotted path using a JSON literal value.
+   *
+   * `key` identifies the field to update. Use `.` to address nested objects,
+   * for example `compactor_options.max_sst_size` or
+   * `object_store_cache_options.root_folder`.
+   *
+   * `value_json` must be a valid JSON literal matching the target field's
+   * expected type. That means strings must be quoted JSON strings, numbers
+   * should be passed as JSON numbers, booleans as `true`/`false`, and
+   * optional fields can be cleared with `null`.
+   *
+   * Missing or `null` intermediate objects in the dotted path are created
+   * automatically. If the update would produce an invalid `slatedb::Settings`
+   * value, the method returns an error and leaves the current settings
+   * unchanged.
+   *
+   * Examples:
+   *
+   * - `set("flush_interval", "\"250ms\"")`
+   * - `set("default_ttl", "42")`
+   * - `set("default_ttl", "null")`
+   * - `set("compactor_options.max_sst_size", "33554432")`
+   * - `set("object_store_cache_options.root_folder", "\"/tmp/slatedb-cache\"")`
+   */
+  set(key: string, value_json: string): void;
+  /**
+   * Serializes the current settings value to a JSON string.
+   */
+  to_json_string(): string;
+}
+
+/**
+ * Handle for a single WAL file.
+ */
+export declare class WalFile extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Returns the WAL file ID.
+   */
+  id(): bigint | number;
+  /**
+   * Opens an iterator over raw row entries in this WAL file.
+   */
+  iterator(): Promise<WalFileIterator>;
+  /**
+   * Reads object-store metadata for this WAL file.
+   */
+  metadata(): Promise<WalFileMetadata>;
+  /**
+   * Returns a handle for the next WAL file ID without checking existence.
+   */
+  next_file(): WalFile;
+  /**
+   * Returns the WAL ID immediately after this file.
+   */
+  next_id(): bigint | number;
+}
+
+/**
+ * Iterator over raw row entries stored in a WAL file.
+ */
+export declare class WalFileIterator extends UniffiObjectBase {
+  protected constructor();
+  /**
+   * Returns the next raw row entry from the WAL file.
+   */
+  next(): Promise<RowEntry | undefined>;
+}
+
+/**
+ * Reader for WAL files stored under a database path.
+ */
+export declare class WalReader extends UniffiObjectBase {
+  /**
+   * Creates a WAL reader for `path` in `object_store`.
+   */
+  constructor(path: string, object_store: ObjectStore);
+  /**
+   * Returns a handle for the WAL file with the given ID.
+   */
+  get(id: bigint | number): WalFile;
+  /**
+   * Lists WAL files in ascending ID order.
+   *
+   * `start_id` is inclusive and `end_id` is exclusive when provided.
+   */
+  list(start_id: bigint | number | undefined, end_id: bigint | number | undefined): Promise<Array<WalFile>>;
+}
+
+/**
+ * Mutable batch of write operations applied atomically by [`crate::Db::write`].
+ *
+ * A batch is single-use once submitted to the database.
+ */
+export declare class WriteBatch extends UniffiObjectBase {
+  /**
+   * Creates an empty write batch.
+   */
+  constructor();
+  /**
+   * Appends a delete operation to the batch.
+   */
+  delete(key: Uint8Array): void;
+  /**
+   * Appends a merge operation to the batch.
+   */
+  merge(key: Uint8Array, operand: Uint8Array): void;
+  /**
+   * Appends a merge operation with custom merge options.
+   */
+  merge_with_options(key: Uint8Array, operand: Uint8Array, options: MergeOptions): void;
+  /**
+   * Appends a put operation to the batch.
+   */
+  put(key: Uint8Array, value: Uint8Array): void;
+  /**
+   * Appends a put operation with custom put options.
+   */
+  put_with_options(key: Uint8Array, value: Uint8Array, options: PutOptions): void;
+}