* Specify the source table or subquery for the query * * @param source - An object with a single key-value pair where the key is the table alias

* Filter rows based on a condition * * @param callback - A function that receives table references and returns an expression * @returns A Que

* Finds a pair in the tree and returns the associated value. * @param defaultValue a value to return if the key was not found. * @returns the va

* Preload the collection data by starting sync if not already started * Multiple concurrent calls will share the same promise

* Create a new array with the results of calling a function for each entry in the collection

* Returns true if the key exists in the B+ tree, false if not. * Use get() for best performance; use has() if you need to * distinguish between

* Commit the transaction and execute the mutation function * @returns Promise that resolves to this transaction when complete * @example * //

* Apply a function to all records in the collection.

* Inserts `child` at index `i`. * This does not mark `child` as shared, so it is the responsibility of the caller * to ensure that either child

* Sort the query results by one or more columns * * @param callback - A function that receives table references and returns the field to sort by

* Functional variants of the query builder * These are imperative function that are called for ery row. * Warning: that these cannot be optimize

* Adds or overwrites a key-value pair in the B+ tree. * @param key the key is used to determine the sort order of * data in the tree.

* Returns an iterator for the map's values in sorted order * * @returns An iterator for the map's values

* Clean up the collection by stopping sync and clearing data * This can be called manually or automatically by garbage collection

* Removes a single key-value pair from the B+ tree. * @param key Key to find * @returns true if a pair was found and removed, false otherwise.

* Join another table or subquery to the current query * * @param source - An object with a single key-value pair where the key is the table alia

* Filter out records for which a function f(record) evaluates to False.

* Gets the current state of the collection as a Map, but only resolves when data is available * Waits for the first sync commit to complete before

* Subscribe to changes in the collection * @param callback - Function called when items change * @param options - Subscription options including

* Executes a callback function for each key-value pair in the map in sorted order * * @param callbackfn - Function to execute for each entry

* Adds a value to the index

* Execute collection operations within this transaction * @param callback - Synchronous function containing collection operations to group together

* Limit the number of rows returned by the query * `orderBy` is required for `limit` * * @param count - Maximum number of rows to return *

* Requests the sync layer to load more data. * @param options Options to control what data is being loaded * @returns If data loading is asynchr

* Wait for an event to be emitted * @param event - Event name to wait for * @param timeout - Optional timeout in milliseconds * @returns Prom

* This method returns all values for a given key. * @param key - The key to get the values for. * @returns An array of value tuples [value, mult

* Updates a value in the index

* Group rows by one or more columns for aggregation * * @param callback - A function that receives table references and returns the field(s) to

* This method returns a string representation of the index. * @param indent - Whether to indent the string representation. * @returns A string r

* This method joins two indexes. * @param other - The index to join with the current index. * @returns A multiset of the joined values.

* Update the value for a key using a function.

* Gets the current status of the collection

Releases the tree so that its size is 0.

* Subscribe to an event * @param event - Event name to listen for * @param callback - Function to call when event is emitted * @returns Unsub

* This method checks if the index has a given key. * @param key - The key to check. * @returns True if the index has the key, false otherwise.

* @returns A promise which will resolve once the specified operation has been seen.

* Creates an index on a collection for faster queries. * Indexes significantly improve query performance by allowing constant time lookups * and

* Extracts child collection items as a sorted plain array for comparison.

* Returns the current state of the collection as an array of changes * @param options - Options including optional where filter * @returns An ar

* Specify that the query should return a single result * @returns A QueryBuilder that returns the first result * * @example * ```ts * /

* Returns an iterator for the map's keys in sorted order * * @returns An iterator for the map's keys

* Start sync immediately - internal method for compiled queries * This bypasses lazy loading for special cases like live query results