@trust0/ridb-core 1.7.42 → 1.8.0

package/build/ridb_core.d.ts

@@ -28,15 +28,25 @@ declare function __wbgtest_console_debug(args: Array<any>): void;
 */
 declare function __wbgtest_console_info(args: Array<any>): void;
 /**
+* Handler for `console.warn` invocations. See above.
+* @param {Array<any>} args
+*/
+declare function __wbgtest_console_warn(args: Array<any>): void;
+/**
 * Handler for `console.error` invocations. See above.
 * @param {Array<any>} args
 */
 declare function __wbgtest_console_error(args: Array<any>): void;
 /**
-* Handler for `console.warn` invocations. See above.
-* @param {Array<any>} args
 */
-declare function __wbgtest_console_warn(args: Array<any>): void;
+declare enum Errors {
+  Error = 0,
+  HookError = 1,
+  QueryError = 2,
+  SerializationError = 3,
+  ValidationError = 4,
+  AuthenticationError = 5,
+}
 /**
 * Represents the type of operation to be performed on the collection.
 */
@@ -62,49 +72,26 @@ declare enum OpType {
 */
   COUNT = 4,
 }
-/**
-*/
-declare enum Errors {
-  Error = 0,
-  HookError = 1,
-  QueryError = 2,
-  SerializationError = 3,
-  ValidationError = 4,
-  AuthenticationError = 5,
-}
-
-type Operators<T> = {
-    $gte?: number,
-    $gt?: number
-    $lt?: number,
-    $lte?: number,
-    $eq?: T,
-    $ne?: T
-};
-
-type InOperator<T> = {  $in?: T[] };
-type NInOperator<T> = {  $nin?: T[] };
-
-type OperatorOrType<T> = T extends number ? 
-    T | Operators<T> | InOperator<T> | NInOperator<T> : 
-    T | InOperator<T> | NInOperator<T>;
 
-type LogicalOperators<T extends SchemaType> = {
-    $and?: Partial<QueryType<T>>[];
-    $or?: Partial<QueryType<T>>[];
-};
+/**
+ * Represents an in-memory storage system extending the base storage functionality.
+ *
+ * @template T - The schema type.
+ */
+declare class InMemory<T extends SchemaTypeRecord> extends BaseStorage<T> {
+    /**
+     * Frees the resources used by the in-memory storage.
+     */
+    free(): void;
 
-type QueryType<T extends SchemaType> = ({
-    [K in keyof T['properties']as ExtractType<T['properties'][K]['type']> extends undefined ? never : K]?: OperatorOrType<
-        ExtractType<
-            T['properties'][K]['type']
+    static create<SchemasCreate extends SchemaTypeRecord>(
+        dbName: string,
+        schemas: SchemasCreate,
+    ): Promise<
+        InMemory<
+            SchemasCreate
         >
-    >
-} & LogicalOperators<T>) | LogicalOperators<T>[];
-
-declare class Query<T extends SchemaType> {
-    constructor(query: QueryType<T>, schema:Schema<T>);
-    readonly query: QueryType<T>;
+    >;
 }
 
 
@@ -138,243 +125,430 @@ declare const SchemaFieldType = {
 
 
 
-declare class CoreStorage {
-    /**
-    * @param {any} document
-    * @param {Query} query
-    * @returns {boolean}
-    */
-    matchesQuery(document: any, query: Query<any>): boolean;
-    getPrimaryKeyTyped(value: any): string | number;
-    getIndexes(schema: Schema<any>, op: Operation): string[];
-}
-
-
-
+type InternalsRecord = {
+    [name: string]: BaseStorage<SchemaTypeRecord>
+};
 /**
- * Represents an IndexDB storage system extending the base storage functionality.
+ * ExtractType is a utility type that maps a string representing a basic data type to the actual TypeScript type.
  *
- * @template T - The schema type.
+ * @template T - A string literal type representing the basic data type ('string', 'number', 'boolean', 'object', 'array').
+ *
+ * @example
+ * type StringType = ExtractType<'string'>; // StringType is string
+ * type NumberType = ExtractType<'number'>; // NumberType is number
+ * type BooleanType = ExtractType<'boolean'>; // BooleanType is boolean
+ * type ObjectType = ExtractType<'object'>; // ObjectType is object
+ * type ArrayType = ExtractType<'array'>; // ArrayType is Array<any>
  */
-declare class IndexDB<T extends SchemaTypeRecord> extends BaseStorage<T> {
-    /**
-     * Frees the resources used by the in-memory storage.
-     */
-    free(): void;
-
-    static create<SchemasCreate extends SchemaTypeRecord>(
-        dbName: string,
-        schemas: SchemasCreate,
-    ): Promise<
-        IndexDB<
-            SchemasCreate
-        >
-    >;
-}
-
-
-
-type EnumerateUpTo<
-    N extends number,
-    Acc extends number[] = []
-> = Acc['length'] extends N ?
-    Acc[number]:
-    EnumerateUpTo<N, [...Acc, Acc['length']]> ;
-
-type EnumerateFrom1To<
-    N extends number
-> = Exclude<EnumerateUpTo<N>,0> | (N extends 0 ? never : N);
-
-type IsVersionGreaterThan0<
-    V extends number
-> = V extends 0 ? false : true;
-
-type AnyVersionGreaterThan1<
-    T extends Record<string, SchemaType>
-> = true extends {
-    [K in keyof T]: IsVersionGreaterThan0<T[K]['version']>;
-} [keyof T] ? true : false;
-
-type MigrationFunction<T extends SchemaType> = (doc: Doc <T> ) => Doc <T>
-
-type MigrationPathsForSchema<
-    T extends SchemaType
-> = T['version'] extends 0 ? {}: // No migrations needed for version 1
-    {
-        [K in EnumerateFrom1To < T['version'] > ]: MigrationFunction<T> ;
-    };
-
-type MigrationPathsForSchemas<
-    T extends SchemaTypeRecord
-> = {
-    [K in keyof T]: MigrationPathsForSchema<T[K]>;
-};
-
-type MigrationsParameter<
-    T extends SchemaTypeRecord
-> = AnyVersionGreaterThan1<T> extends true ?
-    {
-        migrations: MigrationPathsForSchemas<T>
-    }:
-    {
-        migrations?: never
-    };
-
-
+type ExtractType<T extends string> =
+  T extends "string" ? string :
+  T extends "number" ? number :
+  T extends "boolean" ? boolean :
+  T extends "object" ? object :
+  T extends "array" ? any[] :
+  undefined;
 
 /**
- * Represents an operation to be performed on a collection.
+ * ExtractProperty maps a full Property definition to its document type. Unlike
+ * {@link ExtractType} (which only looks at the `type` string), it recurses into
+ * `items` for arrays and `properties` for objects, producing precise nested types.
  *
- * @template T - The schema type of the collection.
+ * @example
+ * type Tags = ExtractProperty<{ type: "array"; items: { type: "string" } }>; // string[]
+ * type Obj  = ExtractProperty<{ type: "object"; properties: { id: { type: "string" } } }>; // { id: string }
  */
-type Operation<T extends SchemaType = SchemaType> = {
-    /**
-     * The name of the collection on which the operation will be performed.
-     */
-    collection: string,
-
-    /**
-     * The type of operation to be performed (e.g., CREATE, UPDATE, DELETE).
-     */
-    opType: OpType,
-
-    /**
-     * The data involved in the operation, conforming to the schema type.
-     */
-    data: Doc<T>,
-
-    primaryKeyField?: string,
-    primaryKey?: string
-}
-
-
+type ExtractProperty<P> =
+  P extends { type: "string" } ? string :
+  P extends { type: "number" } ? number :
+  P extends { type: "boolean" } ? boolean :
+  P extends { type: "array" } ? (P extends { items: infer I } ? ExtractProperty<I>[] : any[]) :
+  P extends { type: "object" } ? (P extends { properties: infer PR } ? ExtractObject<PR, NestedRequiredNames<P>> : object) :
+  unknown;
 
 /**
- * Represents an in-memory storage system extending the base storage functionality.
- *
- * @template T - The schema type.
+ * NestedRequiredNames extracts the union of nested property names listed in an object
+ * property's `required` array (JSON Schema semantics), or `never` when no array is
+ * present. Note it only matches the array form; a boolean `required` flag yields `never`.
  */
-declare class InMemory<T extends SchemaTypeRecord> extends BaseStorage<T> {
-    /**
-     * Frees the resources used by the in-memory storage.
-     */
-    free(): void;
-
-    static create<SchemasCreate extends SchemaTypeRecord>(
-        dbName: string,
-        schemas: SchemasCreate,
-    ): Promise<
-        InMemory<
-            SchemasCreate
-        >
-    >;
-}
-
-
+type NestedRequiredNames<P> =
+  P extends { required: infer R }
+    ? (R extends readonly string[] ? R[number] : never)
+    : never;
 
 /**
- * Represents a property within a schema, including various constraints and nested properties.
+ * FlagRequiredness interprets a property's `required` declaration when it is used as a
+ * legacy boolean flag. Because `Property.required` is typed `boolean | string[]`, a
+ * schema literal written without `as const` widens `true`/`false` to `boolean`; the
+ * tuple-wrapped checks below classify each case:
+ *  - a literal `false` -> `"optional"`;
+ *  - a literal `true`, or a widened `boolean` (whose literal was lost) -> `"required"`.
+ *    Treating the ambiguous `boolean` as required matches the Rust validator and turns a
+ *    would-be runtime "missing required property" error into a compile-time one instead;
+ *  - the array form, or no `required` key -> `"defer"` to the container `required` array.
  */
-declare class Property {
-    /**
-     * The type of the property.
-     */
-    readonly type: SchemaFieldType;
+type FlagRequiredness<P> =
+  P extends { required: infer F }
+    ? ([F] extends [readonly string[]] ? "defer"
+       : [F] extends [false] ? "optional"
+       : [true] extends [F] ? "required"
+       : "defer")
+    : "defer";
 
+/**
+ * IsNestedOptional decides whether a nested property `K` (within an object property's
+ * `properties` map `PR`, given that object's required-name union `R`) may be omitted.
+ * Precedence mirrors the runtime validator and {@link IsCreateOptional}:
+ *  1. a declared `default` makes the field optional;
+ *  2. a boolean `required` flag wins (`false` -> optional, `true`/`boolean` -> required);
+ *  3. otherwise it is required iff listed in the object's `required` array;
+ *  4. otherwise it is optional.
+ */
+type IsNestedOptional<PR, K extends keyof PR, R> =
+  PR[K] extends { default: unknown } ? true
+    : FlagRequiredness<PR[K]> extends "optional" ? true
+    : FlagRequiredness<PR[K]> extends "required" ? false
+    : K extends R ? false
+    : true;
+
+/**
+ * ExtractObject builds an object document type from a `properties` map `PR` and the
+ * owning object's required-name union `R`, applying the correct optional/required
+ * modifier to each nested property (see {@link IsNestedOptional}). This keeps `Doc` and
+ * `CreateDoc` in step with the runtime validator, which only enforces nested keys named
+ * in that object's `required` array.
+ */
+type ExtractObject<PR, R> = {
+  [K in keyof PR as IsNestedOptional<PR, K, R> extends true ? never : K]:
+    ExtractProperty<PR[K]>
+} & {
+  [K in keyof PR as IsNestedOptional<PR, K, R> extends true ? K : never]?:
+    ExtractProperty<PR[K]>
+};
+
+/**
+ * The union of property names marked required at the schema level (JSON Schema
+ * `required` array). Resolves to `never` when no `required` array is present.
+ */
+type RequiredFieldNames<T extends SchemaType> =
+  T extends { required: infer R }
+    ? (R extends readonly string[] ? R[number] : never)
+    : never;
+
+/**
+ * IsCreateOptional decides whether a property may be omitted when creating a document.
+ * Precedence (mirrors the runtime validator):
+ *  1. a declared `default` makes the field optional;
+ *  2. a boolean `required` flag wins (`false` -> optional, `true`/`boolean` -> required;
+ *     see {@link FlagRequiredness});
+ *  3. otherwise it is required iff listed in the schema-level `required` array;
+ *  4. otherwise it is optional.
+ */
+type IsCreateOptional<T extends SchemaType, K extends keyof T["properties"]> =
+  T["properties"][K] extends { default: unknown } ? true
+    : FlagRequiredness<T["properties"][K]> extends "optional" ? true
+    : FlagRequiredness<T["properties"][K]> extends "required" ? false
+    : K extends RequiredFieldNames<T> ? false
+    : true;
+
+/**
+ * Doc is a utility type that transforms a schema type into a stored-document type. A
+ * property is mandatory only when the validator guarantees its presence; properties that
+ * are optional at creation (not listed in `required`, flagged `required: false`, or
+ * carrying a `default`) may be absent on a stored document, so they are optional here
+ * too. This keeps `find`/`findById`/`create` return types from claiming keys that may not
+ * exist. Optionality uses the same {@link IsCreateOptional} rules as {@link CreateDoc}.
+ *
+ * @template T - A schema type with a 'properties' field where each property's type is represented as a string.
+ *
+ * type Document = Doc<Schema>; // Document is { name: string; age: number; }
+ */
+type Doc<T extends SchemaType> = {
+  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? never : K]:
+    ExtractProperty<T['properties'][K]>
+} & {
+  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? K : never]?:
+    ExtractProperty<T['properties'][K]>
+} & {
+  __version?: number;
+  /**
+   * Unix timestamp (in seconds) set automatically when the document is created.
+   * Managed internally by RIDB — it cannot be set or changed by the caller.
+   */
+  createdAt: number;
+  /**
+   * Unix timestamp (in seconds) refreshed automatically on every create/update.
+   * Managed internally by RIDB — it cannot be set or changed by the caller.
+   */
+  updatedAt: number;
+};
+
+/**
+ * CreateDoc is a utility type for document creation that properly handles required vs optional fields
+ * during the creation process. Fields with default values, or fields not listed in the schema-level
+ * `required` array, become optional.
+ *
+ * @template T - A schema type with a 'properties' field where each property's type is represented as a string.
+ */
+type CreateDoc<T extends SchemaType> = {
+  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? K : never]?:
+    ExtractProperty<T['properties'][K]>
+} & {
+  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? never : K]:
+    ExtractProperty<T['properties'][K]>
+} &  {
+  __version?: number;
+};
+
+/**
+ * UpdateDoc is the accepted input shape for `Collection.update`. It is a partial
+ * document keyed by the schema properties. The internally-managed timestamp fields
+ * (`createdAt`/`updatedAt`) are intentionally excluded — they are set and refreshed
+ * by RIDB and cannot be provided by the caller.
+ */
+type UpdateDoc<T extends SchemaType> = Partial<Omit<Doc<T>, "createdAt" | "updatedAt">>;
+
+/**
+ * The direction used when sorting query results by a given field.
+ */
+type SortDirection = 'asc' | 'desc';
+
+/**
+ * A single sort instruction: which field to sort by and in which direction.
+ * `field` is constrained to the schema's property names, and `direction`
+ * defaults to `'asc'` when omitted.
+ */
+type SortSpec<T extends SchemaType = SchemaType> = {
+    field: (keyof T['properties'] & string) | 'createdAt' | 'updatedAt';
+    direction?: SortDirection;
+};
+
+type QueryOptions<T extends SchemaType = SchemaType> = {
+    limit?: number;
+    offset?: number;
     /**
-     * The version of the property, if applicable.
+     * Sorts the results by one or more fields. Accepts a single sort specification
+     * or an array of them (applied in order, the first field being the primary sort key).
      */
-    readonly version?: number;
+    sort?: SortSpec<T> | SortSpec<T>[];
+}
+
+/**
+ * Collection is a class that represents a collection of documents in a database.
+ * @template T - A schema type defining the structure of the documents in the collection.
+ */
+declare class Collection<T extends SchemaType> {
+	/**
+	 * Finds all documents in the collection.
+	 *
+	 * @returns A promise that resolves to an array of documents.
+	 */
+	find(query: QueryType<T>, options?: QueryOptions<T>): Promise<Doc<T>[]>;
+	/**
+	 * count all documents in the collection.
+	 *
+	 * @returns A promise that resolves to an array of documents.
+	 */
+	count(query: QueryType<T>, options?: QueryOptions<T>): Promise<number>;
+	/**
+	 * Finds a single document in the collection by its ID.
+	 *
+	 * @param id - The ID of the document to find.
+	 * @returns A promise that resolves to the found document.
+	 */
+	findById(id: string): Promise<Doc<T>>;
+	/**
+	 * Updates a document in the collection by its ID.
+	 *
+	 * @param document - A partial document containing the fields to update.
+	 * @returns A promise that resolves when the update is complete.
+	 */
+	update(document: UpdateDoc<T>): Promise<void>;
+	/**
+	 * Creates a new document in the collection.
+	 *
+	 * @param document - The document to create.
+	 * @returns A promise that resolves to the created document.
+	 */
+	create(document: CreateDoc<T>): Promise<Doc<T>>;
+	/**
+	 * Deletes a document in the collection by its ID.
+	 *
+	 * @param id - The ID of the document to delete.
+	 * @returns A promise that resolves when the deletion is complete.
+	 */
+	delete(id: string): Promise<void>;
+}
 
+
+
+
+/**
+ * Represents the type definition for a schema.
+ */
+type SchemaType = {
     /**
-     * The primary key of the property, if applicable.
+     * The version of the schema.
      */
-    readonly primaryKey?: string;
+     version: number;
 
     /**
-     * An optional array of nested properties for array-type properties.
+     * The primary key of the schema.
      */
-    readonly items?: Property;
+     primaryKey: string;
 
     /**
-     * The maximum number of items for array-type properties, if applicable.
+     * The type of the schema.
      */
-    readonly maxItems?: number;
+     type: SchemaFieldType;
+     indexes?:  string[];
+     encrypted?:  string[];
+     /**
+      * The names of the required top-level properties. Follows JSON Schema
+      * semantics: only the listed properties are required.
+      */
+     required?: string[];
+    /**
+     * The properties defined in the schema.
+     */
+     properties: {
+        [name: string]: Property;
+    };
+};
 
+
+/**
+ * Represents a schema, including its definition and related methods.
+ * You may be trying to build a storage, in any other can u won't need access tho this class.
+ * Check this example 
+ * 
+ * ```typescript
+ * class MyStorage extends <T extends SchemaTypeRecord> extends BaseStorage<T> {
+ *  example() {
+ *    const schema: Schema<any> = this.getSchema("mySchema")
+ *  }
+ * }
+ * ```
+ * You alwayswill have access to getSchema through the Storage class.
+ * 
+ * @template T - The schema type.
+ */
+declare class Schema<T extends SchemaType> {
     /**
-     * The minimum number of items for array-type properties, if applicable.
+     * The schema definition.
      */
-    readonly minItems?: number;
+    schema: Schema<T>;
 
     /**
-     * The maximum length for string-type properties, if applicable.
+     * Creates a new `Schema` instance from the provided definition.
+     *
+     * @template TS - The schema type.
+     * @param {TS} defi, Debugnition - The schema definition.
+     * @returns {Schema<TS>} The created `Schema` instance.
      */
-    readonly maxLength?: number;
+    static create<TS extends SchemaType>(definition: TS): Schema<TS>;
 
     /**
-     * The minimum length for string-type properties, if applicable.
+     * The version of the schema.
      */
-    readonly minLength?: number;
+    readonly version: number;
 
     /**
-     * Controls requiredness. Two forms are supported and interoperate:
-     *  - `boolean`: a per-property flag (legacy). `false` forces the property optional,
-     *    `true` forces it required, overriding any container-level `required` array.
-     *  - `string[]`: for object-type properties, the JSON Schema list of required
-     *    nested properties.
+     * The primary key of the schema.
      */
-    readonly required?: boolean | string[];
+    readonly primaryKey: string;
 
     /**
-     * An optional default value for the property.
+     * The type of the schema.
      */
-    readonly default?: any;
+    readonly type: SchemaFieldType;
 
     /**
-     * An optional map of nested properties for object-type properties.
+     * An optional array of indexes.
      */
-    readonly properties?: {
-        [name: string]: Property;
+    /**
+     * An optional array of indexes.
+     */
+    readonly indexes?: (Extract<keyof T, string>)[];
+
+    /**
+     * An optional array of encrypted fields.
+     */
+    readonly encrypted?: (Extract<keyof T, string>)[];
+
+    /**
+     * The properties defined in the schema.
+     */
+    readonly properties: {
+        [K in keyof T['properties']]: T['properties'][K];
     };
+
+    /**
+     * The names of the required top-level properties.
+     */
+    readonly required?: (Extract<keyof T['properties'], string>)[];
+    /**
+     * Converts the schema to a JSON representation.
+     *
+     * @returns {SchemaType} The JSON representation of the schema.
+     */
+    toJSON(): SchemaType;
+
+    /**
+     * Validates a document against the schema. The runtime applies the same
+     * optional/required rules as creation (only `required` fields, without a `default`,
+     * must be present), so the accepted shape is `CreateDoc<T>` rather than a fully-keyed
+     * `Doc<T>`.
+     */
+    validate(document: CreateDoc<T>): boolean;
 }
 
 
 
+type Operators<T> = {
+    $gte?: number,
+    $gt?: number
+    $lt?: number,
+    $lte?: number,
+    $eq?: T,
+    $ne?: T
+};
+
+type InOperator<T> = {  $in?: T[] };
+type NInOperator<T> = {  $nin?: T[] };
+
+type OperatorOrType<T> = T extends number ? 
+    T | Operators<T> | InOperator<T> | NInOperator<T> : 
+    T | InOperator<T> | NInOperator<T>;
+
+type LogicalOperators<T extends SchemaType> = {
+    $and?: Partial<QueryType<T>>[];
+    $or?: Partial<QueryType<T>>[];
+};
+
 /**
- * Represents a record of schema types, where each key is a string and the value is a `SchemaType`.
- * @internal
+ * The internally-managed timestamp fields available for querying on every collection.
+ * They cannot be written by the caller but can be filtered (and sorted) like numbers.
  */
-type SchemaTypeRecord = {
-    [name: string]: SchemaType
+type ManagedTimestampsQuery = {
+    createdAt?: OperatorOrType<number>;
+    updatedAt?: OperatorOrType<number>;
 };
 
-declare abstract class StorageInternal<Schemas extends SchemaTypeRecord> {
-    constructor(
-        name: string, 
-        schemas: Schemas
-    );
-    abstract start(): Promise<void>;
-    abstract close(): Promise<void>;
-    abstract count(
-        colectionName: keyof Schemas, 
-        query: QueryType<Schemas[keyof Schemas]>,
-        options?: QueryOptions
-    ): Promise<number>;
-    abstract findDocumentById(
-        collectionName: keyof Schemas, 
-        id: string
-    ): Promise<Doc<Schemas[keyof Schemas]> | null>;
-    abstract find(
-        collectionName: keyof Schemas, 
-        query: QueryType<Schemas[keyof Schemas]>,
-        options?: QueryOptions
-    ): Promise<Doc<Schemas[keyof Schemas]>[]>;
-    abstract write(
-        op: Operation<Schemas[keyof Schemas]>
-    ): Promise<Doc<Schemas[keyof Schemas]>>;
+type QueryType<T extends SchemaType> = ({
+    [K in keyof T['properties']as ExtractType<T['properties'][K]['type']> extends undefined ? never : K]?: OperatorOrType<
+        ExtractType<
+            T['properties'][K]['type']
+        >
+    >
+} & ManagedTimestampsQuery & LogicalOperators<T>) | LogicalOperators<T>[];
+
+declare class Query<T extends SchemaType> {
+    constructor(query: QueryType<T>, schema:Schema<T>);
+    readonly query: QueryType<T>;
 }
 
 
+
 type Hook = (
     schema: Schema<SchemaType>,
     migration: MigrationPathsForSchema<SchemaType>,
@@ -393,43 +567,6 @@ declare class BasePlugin implements BasePluginOptions {
 
 
 
-type BaseStorageOptions =  {
-    [name:string]:string | boolean | number
-}
-
-declare class BaseStorage<Schemas extends SchemaTypeRecord> extends StorageInternal<Schemas> {
-    static create<SchemasCreate extends SchemaTypeRecord>(
-        dbName: string,
-        schemas: SchemasCreate,
-        options?: BaseStorageOptions
-    ): Promise<
-        BaseStorage<
-            SchemasCreate
-        >
-    >;
-    constructor(
-        dbName: string, 
-        schemas: Schemas, 
-        options?: BaseStorageOptions
-    );
-    readonly dbName: string;
-    readonly schemas: Record<keyof Schemas, Schema<Schemas[keyof Schemas]>>;
-    readonly options: BaseStorageOptions;
-    readonly core: CoreStorage;
-    start(): Promise<void>;
-    close(): Promise<void>;
-    count(colectionName: keyof Schemas, query: QueryType<Schemas[keyof Schemas]>, options?: QueryOptions): Promise<number>;
-    findDocumentById(collectionName: keyof Schemas, id: string): Promise<Doc<Schemas[keyof Schemas]> | null>;
-    find(collectionName: keyof Schemas, query: QueryType<Schemas[keyof Schemas]>, options?: QueryOptions): Promise<Doc<Schemas[keyof Schemas]>[]>;
-    write(op: Operation<Schemas[keyof Schemas]>): Promise<Doc<Schemas[keyof Schemas]>>;
-    getOption(name: string): string | boolean | number | undefined;
-    getSchema(name: string): Schema<any>;
-    //Call addIndexSchemas if you need extra indexing schemas for your database
-    addIndexSchemas(): null
-}
-
-
-
 /**
  * Represents a database containing collections of documents.
  * RIDB extends from this class and is used to expose collections.
@@ -534,347 +671,259 @@ type RIDBModule = {
 
 
 
-type InternalsRecord = {
-    [name: string]: BaseStorage<SchemaTypeRecord>
-};
-/**
- * ExtractType is a utility type that maps a string representing a basic data type to the actual TypeScript type.
- *
- * @template T - A string literal type representing the basic data type ('string', 'number', 'boolean', 'object', 'array').
- *
- * @example
- * type StringType = ExtractType<'string'>; // StringType is string
- * type NumberType = ExtractType<'number'>; // NumberType is number
- * type BooleanType = ExtractType<'boolean'>; // BooleanType is boolean
- * type ObjectType = ExtractType<'object'>; // ObjectType is object
- * type ArrayType = ExtractType<'array'>; // ArrayType is Array<any>
- */
-type ExtractType<T extends string> =
-  T extends "string" ? string :
-  T extends "number" ? number :
-  T extends "boolean" ? boolean :
-  T extends "object" ? object :
-  T extends "array" ? any[] :
-  undefined;
+type BaseStorageOptions =  {
+    [name:string]:string | boolean | number
+}
 
-/**
- * ExtractProperty maps a full Property definition to its document type. Unlike
- * {@link ExtractType} (which only looks at the `type` string), it recurses into
- * `items` for arrays and `properties` for objects, producing precise nested types.
- *
- * @example
- * type Tags = ExtractProperty<{ type: "array"; items: { type: "string" } }>; // string[]
- * type Obj  = ExtractProperty<{ type: "object"; properties: { id: { type: "string" } } }>; // { id: string }
- */
-type ExtractProperty<P> =
-  P extends { type: "string" } ? string :
-  P extends { type: "number" } ? number :
-  P extends { type: "boolean" } ? boolean :
-  P extends { type: "array" } ? (P extends { items: infer I } ? ExtractProperty<I>[] : any[]) :
-  P extends { type: "object" } ? (P extends { properties: infer PR } ? ExtractObject<PR, NestedRequiredNames<P>> : object) :
-  unknown;
+declare class BaseStorage<Schemas extends SchemaTypeRecord> extends StorageInternal<Schemas> {
+    static create<SchemasCreate extends SchemaTypeRecord>(
+        dbName: string,
+        schemas: SchemasCreate,
+        options?: BaseStorageOptions
+    ): Promise<
+        BaseStorage<
+            SchemasCreate
+        >
+    >;
+    constructor(
+        dbName: string, 
+        schemas: Schemas, 
+        options?: BaseStorageOptions
+    );
+    readonly dbName: string;
+    readonly schemas: Record<keyof Schemas, Schema<Schemas[keyof Schemas]>>;
+    readonly options: BaseStorageOptions;
+    readonly core: CoreStorage;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    count(colectionName: keyof Schemas, query: QueryType<Schemas[keyof Schemas]>, options?: QueryOptions<Schemas[keyof Schemas]>): Promise<number>;
+    findDocumentById(collectionName: keyof Schemas, id: string): Promise<Doc<Schemas[keyof Schemas]> | null>;
+    find(collectionName: keyof Schemas, query: QueryType<Schemas[keyof Schemas]>, options?: QueryOptions<Schemas[keyof Schemas]>): Promise<Doc<Schemas[keyof Schemas]>[]>;
+    write(op: Operation<Schemas[keyof Schemas]>): Promise<Doc<Schemas[keyof Schemas]>>;
+    getOption(name: string): string | boolean | number | undefined;
+    getSchema(name: string): Schema<any>;
+    //Call addIndexSchemas if you need extra indexing schemas for your database
+    addIndexSchemas(): null
+}
 
-/**
- * NestedRequiredNames extracts the union of nested property names listed in an object
- * property's `required` array (JSON Schema semantics), or `never` when no array is
- * present. Note it only matches the array form; a boolean `required` flag yields `never`.
- */
-type NestedRequiredNames<P> =
-  P extends { required: infer R }
-    ? (R extends readonly string[] ? R[number] : never)
-    : never;
 
-/**
- * FlagRequiredness interprets a property's `required` declaration when it is used as a
- * legacy boolean flag. Because `Property.required` is typed `boolean | string[]`, a
- * schema literal written without `as const` widens `true`/`false` to `boolean`; the
- * tuple-wrapped checks below classify each case:
- *  - a literal `false` -> `"optional"`;
- *  - a literal `true`, or a widened `boolean` (whose literal was lost) -> `"required"`.
- *    Treating the ambiguous `boolean` as required matches the Rust validator and turns a
- *    would-be runtime "missing required property" error into a compile-time one instead;
- *  - the array form, or no `required` key -> `"defer"` to the container `required` array.
- */
-type FlagRequiredness<P> =
-  P extends { required: infer F }
-    ? ([F] extends [readonly string[]] ? "defer"
-       : [F] extends [false] ? "optional"
-       : [true] extends [F] ? "required"
-       : "defer")
-    : "defer";
 
-/**
- * IsNestedOptional decides whether a nested property `K` (within an object property's
- * `properties` map `PR`, given that object's required-name union `R`) may be omitted.
- * Precedence mirrors the runtime validator and {@link IsCreateOptional}:
- *  1. a declared `default` makes the field optional;
- *  2. a boolean `required` flag wins (`false` -> optional, `true`/`boolean` -> required);
- *  3. otherwise it is required iff listed in the object's `required` array;
- *  4. otherwise it is optional.
- */
-type IsNestedOptional<PR, K extends keyof PR, R> =
-  PR[K] extends { default: unknown } ? true
-    : FlagRequiredness<PR[K]> extends "optional" ? true
-    : FlagRequiredness<PR[K]> extends "required" ? false
-    : K extends R ? false
-    : true;
+type EnumerateUpTo<
+    N extends number,
+    Acc extends number[] = []
+> = Acc['length'] extends N ?
+    Acc[number]:
+    EnumerateUpTo<N, [...Acc, Acc['length']]> ;
+
+type EnumerateFrom1To<
+    N extends number
+> = Exclude<EnumerateUpTo<N>,0> | (N extends 0 ? never : N);
+
+type IsVersionGreaterThan0<
+    V extends number
+> = V extends 0 ? false : true;
+
+type AnyVersionGreaterThan1<
+    T extends Record<string, SchemaType>
+> = true extends {
+    [K in keyof T]: IsVersionGreaterThan0<T[K]['version']>;
+} [keyof T] ? true : false;
+
+type MigrationFunction<T extends SchemaType> = (doc: Doc <T> ) => Doc <T>
+
+type MigrationPathsForSchema<
+    T extends SchemaType
+> = T['version'] extends 0 ? {}: // No migrations needed for version 1
+    {
+        [K in EnumerateFrom1To < T['version'] > ]: MigrationFunction<T> ;
+    };
 
-/**
- * ExtractObject builds an object document type from a `properties` map `PR` and the
- * owning object's required-name union `R`, applying the correct optional/required
- * modifier to each nested property (see {@link IsNestedOptional}). This keeps `Doc` and
- * `CreateDoc` in step with the runtime validator, which only enforces nested keys named
- * in that object's `required` array.
- */
-type ExtractObject<PR, R> = {
-  [K in keyof PR as IsNestedOptional<PR, K, R> extends true ? never : K]:
-    ExtractProperty<PR[K]>
-} & {
-  [K in keyof PR as IsNestedOptional<PR, K, R> extends true ? K : never]?:
-    ExtractProperty<PR[K]>
+type MigrationPathsForSchemas<
+    T extends SchemaTypeRecord
+> = {
+    [K in keyof T]: MigrationPathsForSchema<T[K]>;
 };
 
-/**
- * The union of property names marked required at the schema level (JSON Schema
- * `required` array). Resolves to `never` when no `required` array is present.
- */
-type RequiredFieldNames<T extends SchemaType> =
-  T extends { required: infer R }
-    ? (R extends readonly string[] ? R[number] : never)
-    : never;
+type MigrationsParameter<
+    T extends SchemaTypeRecord
+> = AnyVersionGreaterThan1<T> extends true ?
+    {
+        migrations: MigrationPathsForSchemas<T>
+    }:
+    {
+        migrations?: never
+    };
 
-/**
- * IsCreateOptional decides whether a property may be omitted when creating a document.
- * Precedence (mirrors the runtime validator):
- *  1. a declared `default` makes the field optional;
- *  2. a boolean `required` flag wins (`false` -> optional, `true`/`boolean` -> required;
- *     see {@link FlagRequiredness});
- *  3. otherwise it is required iff listed in the schema-level `required` array;
- *  4. otherwise it is optional.
- */
-type IsCreateOptional<T extends SchemaType, K extends keyof T["properties"]> =
-  T["properties"][K] extends { default: unknown } ? true
-    : FlagRequiredness<T["properties"][K]> extends "optional" ? true
-    : FlagRequiredness<T["properties"][K]> extends "required" ? false
-    : K extends RequiredFieldNames<T> ? false
-    : true;
 
-/**
- * Doc is a utility type that transforms a schema type into a stored-document type. A
- * property is mandatory only when the validator guarantees its presence; properties that
- * are optional at creation (not listed in `required`, flagged `required: false`, or
- * carrying a `default`) may be absent on a stored document, so they are optional here
- * too. This keeps `find`/`findById`/`create` return types from claiming keys that may not
- * exist. Optionality uses the same {@link IsCreateOptional} rules as {@link CreateDoc}.
- *
- * @template T - A schema type with a 'properties' field where each property's type is represented as a string.
- *
- * type Document = Doc<Schema>; // Document is { name: string; age: number; }
- */
-type Doc<T extends SchemaType> = {
-  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? never : K]:
-    ExtractProperty<T['properties'][K]>
-} & {
-  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? K : never]?:
-    ExtractProperty<T['properties'][K]>
-} & {
-  __version?: number;
-  createdAt?: number;
-  updatedAt?: number;
-};
 
 /**
- * CreateDoc is a utility type for document creation that properly handles required vs optional fields
- * during the creation process. Fields with default values, or fields not listed in the schema-level
- * `required` array, become optional.
- *
- * @template T - A schema type with a 'properties' field where each property's type is represented as a string.
+ * Represents a record of schema types, where each key is a string and the value is a `SchemaType`.
+ * @internal
  */
-type CreateDoc<T extends SchemaType> = {
-  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? K : never]?:
-    ExtractProperty<T['properties'][K]>
-} & {
-  [K in keyof T["properties"] as IsCreateOptional<T, K> extends true ? never : K]:
-    ExtractProperty<T['properties'][K]>
-} &  {
-  __version?: number;
-  createdAt?: number;
-  updatedAt?: number;
+type SchemaTypeRecord = {
+    [name: string]: SchemaType
 };
 
-type QueryOptions = {
-    limit?: number;
-    offset?: number;
+declare abstract class StorageInternal<Schemas extends SchemaTypeRecord> {
+    constructor(
+        name: string, 
+        schemas: Schemas
+    );
+    abstract start(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract count(
+        colectionName: keyof Schemas, 
+        query: QueryType<Schemas[keyof Schemas]>,
+        options?: QueryOptions<Schemas[keyof Schemas]>
+    ): Promise<number>;
+    abstract findDocumentById(
+        collectionName: keyof Schemas, 
+        id: string
+    ): Promise<Doc<Schemas[keyof Schemas]> | null>;
+    abstract find(
+        collectionName: keyof Schemas, 
+        query: QueryType<Schemas[keyof Schemas]>,
+        options?: QueryOptions<Schemas[keyof Schemas]>
+    ): Promise<Doc<Schemas[keyof Schemas]>[]>;
+    abstract write(
+        op: Operation<Schemas[keyof Schemas]>
+    ): Promise<Doc<Schemas[keyof Schemas]>>;
 }
 
+
 /**
- * Collection is a class that represents a collection of documents in a database.
- * @template T - A schema type defining the structure of the documents in the collection.
+ * Represents a property within a schema, including various constraints and nested properties.
  */
-declare class Collection<T extends SchemaType> {
-	/**
-	 * Finds all documents in the collection.
-	 *
-	 * @returns A promise that resolves to an array of documents.
-	 */
-	find(query: QueryType<T>, options?: QueryOptions): Promise<Doc<T>[]>;
-	/**
-	 * count all documents in the collection.
-	 *
-	 * @returns A promise that resolves to an array of documents.
-	 */
-	count(query: QueryType<T>, options?: QueryOptions): Promise<number>;
-	/**
-	 * Finds a single document in the collection by its ID.
-	 *
-	 * @param id - The ID of the document to find.
-	 * @returns A promise that resolves to the found document.
-	 */
-	findById(id: string): Promise<Doc<T>>;
-	/**
-	 * Updates a document in the collection by its ID.
-	 *
-	 * @param document - A partial document containing the fields to update.
-	 * @returns A promise that resolves when the update is complete.
-	 */
-	update(document: Partial<Doc<T>>): Promise<void>;
-	/**
-	 * Creates a new document in the collection.
-	 *
-	 * @param document - The document to create.
-	 * @returns A promise that resolves to the created document.
-	 */
-	create(document: CreateDoc<T>): Promise<Doc<T>>;
-	/**
-	 * Deletes a document in the collection by its ID.
-	 *
-	 * @param id - The ID of the document to delete.
-	 * @returns A promise that resolves when the deletion is complete.
-	 */
-	delete(id: string): Promise<void>;
-}
+declare class Property {
+    /**
+     * The type of the property.
+     */
+    readonly type: SchemaFieldType;
 
+    /**
+     * The version of the property, if applicable.
+     */
+    readonly version?: number;
 
+    /**
+     * The primary key of the property, if applicable.
+     */
+    readonly primaryKey?: string;
 
+    /**
+     * An optional array of nested properties for array-type properties.
+     */
+    readonly items?: Property;
 
-/**
- * Represents the type definition for a schema.
- */
-type SchemaType = {
     /**
-     * The version of the schema.
+     * The maximum number of items for array-type properties, if applicable.
      */
-     version: number;
+    readonly maxItems?: number;
 
     /**
-     * The primary key of the schema.
+     * The minimum number of items for array-type properties, if applicable.
      */
-     primaryKey: string;
+    readonly minItems?: number;
 
     /**
-     * The type of the schema.
+     * The maximum length for string-type properties, if applicable.
      */
-     type: SchemaFieldType;
-     indexes?:  string[];
-     encrypted?:  string[];
-     /**
-      * The names of the required top-level properties. Follows JSON Schema
-      * semantics: only the listed properties are required.
-      */
-     required?: string[];
+    readonly maxLength?: number;
+
     /**
-     * The properties defined in the schema.
+     * The minimum length for string-type properties, if applicable.
      */
-     properties: {
+    readonly minLength?: number;
+
+    /**
+     * Controls requiredness. Two forms are supported and interoperate:
+     *  - `boolean`: a per-property flag (legacy). `false` forces the property optional,
+     *    `true` forces it required, overriding any container-level `required` array.
+     *  - `string[]`: for object-type properties, the JSON Schema list of required
+     *    nested properties.
+     */
+    readonly required?: boolean | string[];
+
+    /**
+     * An optional default value for the property.
+     */
+    readonly default?: any;
+
+    /**
+     * An optional map of nested properties for object-type properties.
+     */
+    readonly properties?: {
         [name: string]: Property;
     };
-};
+}
+
 
 
 /**
- * Represents a schema, including its definition and related methods.
- * You may be trying to build a storage, in any other can u won't need access tho this class.
- * Check this example 
- * 
- * ```typescript
- * class MyStorage extends <T extends SchemaTypeRecord> extends BaseStorage<T> {
- *  example() {
- *    const schema: Schema<any> = this.getSchema("mySchema")
- *  }
- * }
- * ```
- * You alwayswill have access to getSchema through the Storage class.
- * 
+ * Represents an IndexDB storage system extending the base storage functionality.
+ *
  * @template T - The schema type.
  */
-declare class Schema<T extends SchemaType> {
+declare class IndexDB<T extends SchemaTypeRecord> extends BaseStorage<T> {
     /**
-     * The schema definition.
+     * Frees the resources used by the in-memory storage.
      */
-    schema: Schema<T>;
+    free(): void;
+
+    static create<SchemasCreate extends SchemaTypeRecord>(
+        dbName: string,
+        schemas: SchemasCreate,
+    ): Promise<
+        IndexDB<
+            SchemasCreate
+        >
+    >;
+}
 
-    /**
-     * Creates a new `Schema` instance from the provided definition.
-     *
-     * @template TS - The schema type.
-     * @param {TS} defi, Debugnition - The schema definition.
-     * @returns {Schema<TS>} The created `Schema` instance.
-     */
-    static create<TS extends SchemaType>(definition: TS): Schema<TS>;
 
-    /**
-     * The version of the schema.
-     */
-    readonly version: number;
 
+/**
+ * Represents an operation to be performed on a collection.
+ *
+ * @template T - The schema type of the collection.
+ */
+type Operation<T extends SchemaType = SchemaType> = {
     /**
-     * The primary key of the schema.
+     * The name of the collection on which the operation will be performed.
      */
-    readonly primaryKey: string;
+    collection: string,
 
     /**
-     * The type of the schema.
+     * The type of operation to be performed (e.g., CREATE, UPDATE, DELETE).
      */
-    readonly type: SchemaFieldType;
+    opType: OpType,
 
     /**
-     * An optional array of indexes.
-     */
-    /**
-     * An optional array of indexes.
+     * The data involved in the operation, conforming to the schema type.
      */
-    readonly indexes?: (Extract<keyof T, string>)[];
+    data: Doc<T>,
 
-    /**
-     * An optional array of encrypted fields.
-     */
-    readonly encrypted?: (Extract<keyof T, string>)[];
+    primaryKeyField?: string,
+    primaryKey?: string
+}
 
-    /**
-     * The properties defined in the schema.
-     */
-    readonly properties: {
-        [K in keyof T['properties']]: T['properties'][K];
-    };
 
-    /**
-     * The names of the required top-level properties.
-     */
-    readonly required?: (Extract<keyof T['properties'], string>)[];
-    /**
-     * Converts the schema to a JSON representation.
-     *
-     * @returns {SchemaType} The JSON representation of the schema.
-     */
-    toJSON(): SchemaType;
 
+declare class CoreStorage {
     /**
-     * Validates a document against the schema. The runtime applies the same
-     * optional/required rules as creation (only `required` fields, without a `default`,
-     * must be present), so the accepted shape is `CreateDoc<T>` rather than a fully-keyed
-     * `Doc<T>`.
-     */
-    validate(document: CreateDoc<T>): boolean;
+    * @param {any} document
+    * @param {Query} query
+    * @returns {boolean}
+    */
+    matchesQuery(document: any, query: Query<any>): boolean;
+    getPrimaryKeyTyped(value: any): string | number;
+    getIndexes(schema: Schema<any>, op: Operation): string[];
+    /**
+    * Sorts a list of documents according to the provided sort specification, using the
+    * same comparison semantics as the built-in storages. Intended for custom storage
+    * adapters that cannot rely on a native sort. Returns a new sorted array.
+    */
+    sortDocuments(documents: any[], sort: SortSpec[]): any[];
 }
 
 
@@ -989,6 +1038,50 @@ type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Modul
 
 interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_inmemory_free: (a: number) => void;
+  readonly inmemory_close: (a: number) => number;
+  readonly inmemory_count: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly inmemory_create: (a: number, b: number, c: number) => number;
+  readonly inmemory_find: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly inmemory_findDocumentById: (a: number, b: number, c: number, d: number) => number;
+  readonly inmemory_start: (a: number) => number;
+  readonly inmemory_write: (a: number, b: number) => number;
+  readonly __wbg_collection_free: (a: number) => void;
+  readonly __wbg_schema_free: (a: number) => void;
+  readonly __wbgt_test_invalid_schema_5: (a: number) => void;
+  readonly __wbgt_test_schema_creation_3: (a: number) => void;
+  readonly __wbgt_test_schema_required_subset_of_properties_6: (a: number) => void;
+  readonly __wbgt_test_schema_validation_4: (a: number) => void;
+  readonly __wbgt_test_validate_document_default_makes_required_optional_15: (a: number) => void;
+  readonly __wbgt_test_validate_document_flag_overrides_array_12: (a: number) => void;
+  readonly __wbgt_test_validate_document_legacy_required_false_11: (a: number) => void;
+  readonly __wbgt_test_validate_document_nested_required_13: (a: number) => void;
+  readonly __wbgt_test_validate_document_no_array_all_optional_9: (a: number) => void;
+  readonly __wbgt_test_validate_document_null_is_type_checked_14: (a: number) => void;
+  readonly __wbgt_test_validate_document_omitted_nested_required_equals_empty_10: (a: number) => void;
+  readonly __wbgt_test_validate_document_required_missing_8: (a: number) => void;
+  readonly __wbgt_test_validate_document_required_present_7: (a: number) => void;
+  readonly collection_count: (a: number, b: number, c: number) => number;
+  readonly collection_create: (a: number, b: number) => number;
+  readonly collection_delete: (a: number, b: number) => number;
+  readonly collection_find: (a: number, b: number, c: number) => number;
+  readonly collection_findById: (a: number, b: number) => number;
+  readonly collection_name: (a: number, b: number) => void;
+  readonly collection_parse_query_options: (a: number, b: number, c: number) => void;
+  readonly collection_schema: (a: number, b: number) => void;
+  readonly collection_update: (a: number, b: number) => number;
+  readonly is_debug_mode: () => number;
+  readonly main_js: () => void;
+  readonly schema_create: (a: number, b: number) => void;
+  readonly schema_encrypted: (a: number, b: number) => void;
+  readonly schema_indexes: (a: number, b: number) => void;
+  readonly schema_is_valid: (a: number, b: number) => void;
+  readonly schema_primaryKey: (a: number, b: number) => void;
+  readonly schema_properties: (a: number, b: number) => void;
+  readonly schema_required: (a: number, b: number) => void;
+  readonly schema_type: (a: number, b: number) => void;
+  readonly schema_validate: (a: number, b: number, c: number) => void;
+  readonly schema_version: (a: number) => number;
   readonly __wbg_query_free: (a: number) => void;
   readonly __wbgt_test_get_properties_array_values_20: (a: number) => void;
   readonly __wbgt_test_get_properties_deeply_nested_22: (a: number) => void;
@@ -1026,11 +1119,44 @@ interface InitOutput {
   readonly query_parse: (a: number, b: number) => void;
   readonly query_process_query: (a: number, b: number, c: number) => void;
   readonly query_query: (a: number, b: number) => void;
-  readonly __wbg_indexdb_free: (a: number) => void;
+  readonly __wbg_baseplugin_free: (a: number) => void;
+  readonly __wbg_basestorage_free: (a: number) => void;
+  readonly __wbg_database_free: (a: number) => void;
+  readonly baseplugin_get_doc_create_hook: (a: number) => number;
+  readonly baseplugin_get_doc_recover_hook: (a: number) => number;
+  readonly baseplugin_name: (a: number) => number;
+  readonly baseplugin_new: (a: number, b: number, c: number) => void;
+  readonly baseplugin_set_doc_create_hook: (a: number, b: number) => void;
+  readonly baseplugin_set_doc_recover_hook: (a: number, b: number) => void;
+  readonly basestorage_addIndexSchemas: (a: number, b: number) => void;
+  readonly basestorage_core: (a: number, b: number) => void;
+  readonly basestorage_getOption: (a: number, b: number, c: number, d: number) => void;
+  readonly basestorage_getSchema: (a: number, b: number, c: number, d: number) => void;
+  readonly basestorage_new: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly database_authenticate: (a: number, b: number, c: number) => number;
+  readonly database_close: (a: number) => number;
+  readonly database_collections: (a: number, b: number) => void;
+  readonly database_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+  readonly database_start: (a: number) => number;
+  readonly database_started: (a: number) => number;
+  readonly __wbg_property_free: (a: number) => void;
   readonly __wbg_queryoptions_free: (a: number) => void;
-  readonly corestorage_getIndexes: (a: number, b: number, c: number, d: number) => void;
-  readonly corestorage_getPrimaryKeyTyped: (a: number, b: number, c: number) => void;
-  readonly corestorage_matchesQuery: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbgt_test_invalid_property_2: (a: number) => void;
+  readonly __wbgt_test_property_creation_0: (a: number) => void;
+  readonly __wbgt_test_property_validation_1: (a: number) => void;
+  readonly property_is_valid: (a: number, b: number) => void;
+  readonly property_items: (a: number, b: number) => void;
+  readonly property_maxItems: (a: number, b: number) => void;
+  readonly property_maxLength: (a: number, b: number) => void;
+  readonly property_minItems: (a: number, b: number) => void;
+  readonly property_minLength: (a: number, b: number) => void;
+  readonly property_properties: (a: number, b: number) => void;
+  readonly property_type: (a: number) => number;
+  readonly queryoptions_limit: (a: number, b: number) => void;
+  readonly queryoptions_offset: (a: number, b: number) => void;
+  readonly queryoptions_sort: (a: number, b: number) => void;
+  readonly __wbg_indexdb_free: (a: number) => void;
+  readonly __wbg_ridberror_free: (a: number) => void;
   readonly indexdb_close: (a: number) => number;
   readonly indexdb_count: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly indexdb_create: (a: number, b: number, c: number) => number;
@@ -1041,18 +1167,6 @@ interface InitOutput {
   readonly indexdb_get_stores: (a: number, b: number) => void;
   readonly indexdb_start: (a: number) => number;
   readonly indexdb_write: (a: number, b: number) => number;
-  readonly queryoptions_limit: (a: number, b: number) => void;
-  readonly queryoptions_offset: (a: number, b: number) => void;
-  readonly corestorage_new: () => number;
-  readonly __wbg_corestorage_free: (a: number) => void;
-  readonly __wbg_operation_free: (a: number) => void;
-  readonly __wbg_ridberror_free: (a: number) => void;
-  readonly operation_collection: (a: number, b: number) => void;
-  readonly operation_data: (a: number) => number;
-  readonly operation_opType: (a: number) => number;
-  readonly operation_primaryKey: (a: number) => number;
-  readonly operation_primaryKeyField: (a: number) => number;
-  readonly operation_primaryKeyIndex: (a: number, b: number) => void;
   readonly ridberror_authentication: (a: number, b: number, c: number) => number;
   readonly ridberror_code: (a: number) => number;
   readonly ridberror_error: (a: number, b: number, c: number) => number;
@@ -1064,82 +1178,19 @@ interface InitOutput {
   readonly ridberror_serialisation: (a: number, b: number, c: number) => number;
   readonly ridberror_type: (a: number, b: number) => void;
   readonly ridberror_validation: (a: number, b: number, c: number) => number;
-  readonly __wbg_inmemory_free: (a: number) => void;
-  readonly inmemory_close: (a: number) => number;
-  readonly inmemory_count: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly inmemory_create: (a: number, b: number, c: number) => number;
-  readonly inmemory_find: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly inmemory_findDocumentById: (a: number, b: number, c: number, d: number) => number;
-  readonly inmemory_start: (a: number) => number;
-  readonly inmemory_write: (a: number, b: number) => number;
-  readonly __wbg_property_free: (a: number) => void;
-  readonly __wbgt_test_invalid_property_2: (a: number) => void;
-  readonly __wbgt_test_property_creation_0: (a: number) => void;
-  readonly __wbgt_test_property_validation_1: (a: number) => void;
-  readonly property_is_valid: (a: number, b: number) => void;
-  readonly property_items: (a: number, b: number) => void;
-  readonly property_maxItems: (a: number, b: number) => void;
-  readonly property_maxLength: (a: number, b: number) => void;
-  readonly property_minItems: (a: number, b: number) => void;
-  readonly property_minLength: (a: number, b: number) => void;
-  readonly property_properties: (a: number, b: number) => void;
-  readonly property_type: (a: number) => number;
-  readonly __wbg_baseplugin_free: (a: number) => void;
-  readonly __wbg_basestorage_free: (a: number) => void;
-  readonly __wbg_database_free: (a: number) => void;
-  readonly baseplugin_get_doc_create_hook: (a: number) => number;
-  readonly baseplugin_get_doc_recover_hook: (a: number) => number;
-  readonly baseplugin_name: (a: number) => number;
-  readonly baseplugin_new: (a: number, b: number, c: number) => void;
-  readonly baseplugin_set_doc_create_hook: (a: number, b: number) => void;
-  readonly baseplugin_set_doc_recover_hook: (a: number, b: number) => void;
-  readonly basestorage_addIndexSchemas: (a: number, b: number) => void;
-  readonly basestorage_core: (a: number, b: number) => void;
-  readonly basestorage_getOption: (a: number, b: number, c: number, d: number) => void;
-  readonly basestorage_getSchema: (a: number, b: number, c: number, d: number) => void;
-  readonly basestorage_new: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly database_authenticate: (a: number, b: number, c: number) => number;
-  readonly database_close: (a: number) => number;
-  readonly database_collections: (a: number, b: number) => void;
-  readonly database_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
-  readonly database_start: (a: number) => number;
-  readonly database_started: (a: number) => number;
-  readonly __wbg_collection_free: (a: number) => void;
-  readonly __wbg_schema_free: (a: number) => void;
-  readonly __wbgt_test_invalid_schema_5: (a: number) => void;
-  readonly __wbgt_test_schema_creation_3: (a: number) => void;
-  readonly __wbgt_test_schema_required_subset_of_properties_6: (a: number) => void;
-  readonly __wbgt_test_schema_validation_4: (a: number) => void;
-  readonly __wbgt_test_validate_document_default_makes_required_optional_15: (a: number) => void;
-  readonly __wbgt_test_validate_document_flag_overrides_array_12: (a: number) => void;
-  readonly __wbgt_test_validate_document_legacy_required_false_11: (a: number) => void;
-  readonly __wbgt_test_validate_document_nested_required_13: (a: number) => void;
-  readonly __wbgt_test_validate_document_no_array_all_optional_9: (a: number) => void;
-  readonly __wbgt_test_validate_document_null_is_type_checked_14: (a: number) => void;
-  readonly __wbgt_test_validate_document_omitted_nested_required_equals_empty_10: (a: number) => void;
-  readonly __wbgt_test_validate_document_required_missing_8: (a: number) => void;
-  readonly __wbgt_test_validate_document_required_present_7: (a: number) => void;
-  readonly collection_count: (a: number, b: number, c: number) => number;
-  readonly collection_create: (a: number, b: number) => number;
-  readonly collection_delete: (a: number, b: number) => number;
-  readonly collection_find: (a: number, b: number, c: number) => number;
-  readonly collection_findById: (a: number, b: number) => number;
-  readonly collection_name: (a: number, b: number) => void;
-  readonly collection_parse_query_options: (a: number, b: number, c: number) => void;
-  readonly collection_schema: (a: number, b: number) => void;
-  readonly collection_update: (a: number, b: number) => number;
-  readonly schema_create: (a: number, b: number) => void;
-  readonly schema_encrypted: (a: number, b: number) => void;
-  readonly schema_indexes: (a: number, b: number) => void;
-  readonly schema_is_valid: (a: number, b: number) => void;
-  readonly schema_primaryKey: (a: number, b: number) => void;
-  readonly schema_properties: (a: number, b: number) => void;
-  readonly schema_required: (a: number, b: number) => void;
-  readonly schema_type: (a: number, b: number) => void;
-  readonly schema_validate: (a: number, b: number, c: number) => void;
-  readonly schema_version: (a: number) => number;
-  readonly is_debug_mode: () => number;
-  readonly main_js: () => void;
+  readonly __wbg_operation_free: (a: number) => void;
+  readonly corestorage_getIndexes: (a: number, b: number, c: number, d: number) => void;
+  readonly corestorage_getPrimaryKeyTyped: (a: number, b: number, c: number) => void;
+  readonly corestorage_matchesQuery: (a: number, b: number, c: number, d: number) => void;
+  readonly corestorage_sortDocuments: (a: number, b: number, c: number, d: number) => void;
+  readonly operation_collection: (a: number, b: number) => void;
+  readonly operation_data: (a: number) => number;
+  readonly operation_opType: (a: number) => number;
+  readonly operation_primaryKey: (a: number) => number;
+  readonly operation_primaryKeyField: (a: number) => number;
+  readonly operation_primaryKeyIndex: (a: number, b: number) => void;
+  readonly corestorage_new: () => number;
+  readonly __wbg_corestorage_free: (a: number) => void;
   readonly __wbg_wasmbindgentestcontext_free: (a: number) => void;
   readonly __wbgtest_console_debug: (a: number) => void;
   readonly __wbgtest_console_error: (a: number) => void;
@@ -1153,14 +1204,14 @@ interface InitOutput {
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly _dyn_core__ops__function__Fn__A_B_C___Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf68407c2d58ea7a7: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h20b808fdb8c77f5d: (a: number, b: number, c: number) => void;
-  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__haaaa8b1463560632: (a: number, b: number, c: number) => void;
+  readonly _dyn_core_7d5f0a2ba6a62c33___ops__function__Fn____________Output______as_wasm_bindgen_96f4c656f19e5a04___closure__WasmClosure___describe__invoke___wasm_bindgen_96f4c656f19e5a04___JsValue__wasm_bindgen_96f4c656f19e5a04___JsValue__wasm_bindgen_96f4c656f19e5a04___JsValue__core_7d5f0a2ba6a62c33___result__Result_wasm_bindgen_96f4c656f19e5a04___JsValue__ridb_core_aad11e700d7ae026___error__RIDBError__: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly _dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut_______Output______as_wasm_bindgen_96f4c656f19e5a04___closure__WasmClosure___describe__invoke___web_sys_42441b50243cf0a5___features__gen_Event__Event_____: (a: number, b: number, c: number) => void;
+  readonly _dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut_______Output______as_wasm_bindgen_96f4c656f19e5a04___closure__WasmClosure___describe__invoke___wasm_bindgen_96f4c656f19e5a04___JsValue_____: (a: number, b: number, c: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_exn_store: (a: number) => void;
-  readonly wasm_bindgen__convert__closures__invoke0_mut__h637bbedf1d05ab65: (a: number, b: number) => void;
-  readonly wasm_bindgen__convert__closures__invoke2_mut__h413cfbf41bd786a3: (a: number, b: number, c: number, d: number) => void;
-  readonly wasm_bindgen__convert__closures__invoke3_mut__h4efafefcae80b4ef: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly wasm_bindgen_96f4c656f19e5a04___convert__closures__invoke0_mut______: (a: number, b: number) => void;
+  readonly wasm_bindgen_96f4c656f19e5a04___convert__closures__invoke2_mut___wasm_bindgen_96f4c656f19e5a04___JsValue__wasm_bindgen_96f4c656f19e5a04___JsValue_____: (a: number, b: number, c: number, d: number) => void;
+  readonly wasm_bindgen_96f4c656f19e5a04___convert__closures__invoke3_mut___wasm_bindgen_96f4c656f19e5a04___JsValue__wasm_bindgen_96f4c656f19e5a04___JsValue__js_sys_cda727aa608b7f1b___Set_____: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly __wbindgen_start: () => void;
 }
 
@@ -1185,4 +1236,4 @@ declare function initSync(module: SyncInitInput): InitOutput;
 */
 declare function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
 
-export { type AnyVersionGreaterThan1, BasePlugin, BaseStorage, type BaseStorageOptions, Collection, CoreStorage, type CreateDoc, type CreateStorage, Database, type Doc, type EnumerateFrom1To, type EnumerateUpTo, Errors, type ExtractObject, type ExtractProperty, type ExtractType, type FlagRequiredness, InMemory, type InOperator, IndexDB, type InitInput, type InitOutput, type InternalsRecord, type IsCreateOptional, type IsNestedOptional, type IsVersionGreaterThan0, type LogicalOperators, type MigrationFunction, type MigrationPathsForSchema, type MigrationPathsForSchemas, type MigrationsParameter, type NInOperator, type NestedRequiredNames, OpType, type Operation, type OperatorOrType, type Operators, Property, Query, type QueryOptions, type QueryType, RIDBError, type RIDBModule, type RequiredFieldNames, Schema, SchemaFieldType, type SchemaType, type SchemaTypeRecord, StorageInternal, type SyncInitInput, WasmBindgenTestContext, __wbgtest_console_debug, __wbgtest_console_error, __wbgtest_console_info, __wbgtest_console_log, __wbgtest_console_warn, __wbg_init as default, initSync, is_debug_mode, main_js };
+export { type AnyVersionGreaterThan1, BasePlugin, BaseStorage, type BaseStorageOptions, Collection, CoreStorage, type CreateDoc, type CreateStorage, Database, type Doc, type EnumerateFrom1To, type EnumerateUpTo, Errors, type ExtractObject, type ExtractProperty, type ExtractType, type FlagRequiredness, InMemory, type InOperator, IndexDB, type InitInput, type InitOutput, type InternalsRecord, type IsCreateOptional, type IsNestedOptional, type IsVersionGreaterThan0, type LogicalOperators, type ManagedTimestampsQuery, type MigrationFunction, type MigrationPathsForSchema, type MigrationPathsForSchemas, type MigrationsParameter, type NInOperator, type NestedRequiredNames, OpType, type Operation, type OperatorOrType, type Operators, Property, Query, type QueryOptions, type QueryType, RIDBError, type RIDBModule, type RequiredFieldNames, Schema, SchemaFieldType, type SchemaType, type SchemaTypeRecord, type SortDirection, type SortSpec, StorageInternal, type SyncInitInput, type UpdateDoc, WasmBindgenTestContext, __wbgtest_console_debug, __wbgtest_console_error, __wbgtest_console_info, __wbgtest_console_log, __wbgtest_console_warn, __wbg_init as default, initSync, is_debug_mode, main_js };