@trust0/ridb-core 1.0.0-rc.1

package/pkg/ridb_core.d.ts

@@ -0,0 +1,860 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+*/
+export function main_js(): void;
+/**
+* @returns {boolean}
+*/
+export function is_debug_mode(): boolean;
+/**
+* Handler for `console.log` invocations.
+*
+* If a test is currently running it takes the `args` array and stringifies
+* it and appends it to the current output of the test. Otherwise it passes
+* the arguments to the original `console.log` function, psased as
+* `original`.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_log(args: Array<any>): void;
+/**
+* Handler for `console.debug` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_debug(args: Array<any>): void;
+/**
+* Handler for `console.info` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_info(args: Array<any>): void;
+/**
+* Handler for `console.warn` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_warn(args: Array<any>): void;
+/**
+* Handler for `console.error` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_error(args: Array<any>): void;
+/**
+* Represents the type of operation to be performed on the collection.
+*/
+export enum OpType {
+/**
+* Create operation.
+*/
+  CREATE = 0,
+/**
+* Update operation.
+*/
+  UPDATE = 1,
+/**
+* Delete operation.
+*/
+  DELETE = 2,
+/**
+* Query Operation.
+*/
+  QUERY = 3,
+/**
+* Count Operation.
+*/
+  COUNT = 4,
+}
+
+export class CoreStorage {
+    /**
+    * @param {any} document
+    * @param {Query} query
+    * @returns {boolean}
+    */
+    matchesQuery(document: any, query: Query<any>): boolean;
+}
+
+
+
+/**
+ * Represents a database containing collections of documents.
+ * RIDB extends from this class and is used to expose collections.
+ * 
+ * So if you specify:
+ * ```typescript
+ * const db = new RIDB(
+ *     {
+ *         schemas: {
+ *             demo: {
+ *                 version: 0,
+ *                 primaryKey: 'id',
+ *                 type: SchemaFieldType.object,
+ *                 properties: {
+ *                     id: {
+ *                         type: SchemaFieldType.string,
+ *                         maxLength: 60
+ *                     }
+ *                 }
+ *             }
+ *         } as const
+ *     }
+ * )
+ * ```
+ * 
+ * The collection will be available as `db.collections.demo` and all the methods for the collection (find, count, findById, update, create, delete) will be available.
+ *
+ * @template T - A record of schema types.
+ */
+export class Database<T extends SchemaTypeRecord> {
+
+    /**
+     * Creates a new `Database` instance with the provided schemas and storage module.
+     *
+     * @template TS - A record of schema types.
+     * @param {TS} schemas - The schemas to use for the collections.
+     * @param migrations
+     * @param plugins
+     * @param options
+     * @param password
+     * @returns {Promise<Database<TS>>} A promise that resolves to the created `Database` instance.
+     */
+    static create<TS extends SchemaTypeRecord>(
+        db_name: string,
+        schemas: TS,
+        migrations: MigrationPathsForSchemas<TS> | MigrationPathsForSchema<TS[string]>,
+        plugins:Array<typeof BasePlugin>,
+        options: RIDBModule,
+        password?:string,
+        storage?: BaseStorage<TS>
+    ): Promise<Database<TS>>;
+
+    /**
+     * The collections in the database.
+     *
+     * This is a read-only property where the key is the name of the collection and the value is a `Collection` instance.
+     */
+    readonly collections: {
+        [name in keyof T]: Collection<Schema<T[name]>>
+    }
+
+    readonly started: boolean;
+
+    /**
+     * Starts the database.
+     *
+     * @returns {Promise<void>} A promise that resolves when the database is started.
+     */
+    start(): Promise<void>;
+
+    /**
+     * Closes the database.
+     *
+     * @returns {Promise<void>} A promise that resolves when the database is closed.
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Represents a function type for creating storage with the provided schema type records.
+ *
+ * @template T - The schema type record.
+ * @param {T} records - The schema type records.
+ * @returns {Promise<InternalsRecord>} A promise that resolves to the created internals record.
+ */
+export type CreateStorage = <T extends SchemaTypeRecord>(
+    records: T
+) => Promise<BaseStorage<T>>;
+
+/**
+ * Represents a storage module with a method for creating storage.
+ */
+export type RIDBModule = {
+
+    /**
+     * Plugin constructors array
+     */
+    apply: (plugins:Array<typeof BasePlugin>) => Array<BasePlugin>;
+};
+
+
+
+/**
+ * Represents an in-memory storage system extending the base storage functionality.
+ *
+ * @template T - The schema type.
+ */
+export 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
+        >
+    >;
+}
+
+
+
+export type BaseStorageOptions =  {
+    [name:string]:string | boolean | number
+}
+
+export 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]>): Promise<number>;
+    findDocumentById(collectionName: keyof Schemas, id: string): Promise<Doc<Schemas[keyof Schemas]> | null | undefined>;
+    find(collectionName: keyof Schemas, query: QueryType<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>;
+
+}
+
+
+
+/**
+ * Represents the type definition for a schema.
+ */
+export type SchemaType = {
+    /**
+     * The version of the schema.
+     */
+     version: number;
+
+    /**
+     * The primary key of the schema.
+     */
+     primaryKey: string;
+
+    /**
+     * The type of the schema.
+     */
+     type: string;
+     indexes?:  string[];
+     encrypted?:  string[];
+    /**
+     * The properties defined in the schema.
+     */
+     properties: {
+        [name: string]: Property;
+    };
+};
+
+
+/**
+ * Represents a schema, including its definition and related methods.
+ *
+ * @template T - The schema type.
+ */
+export class Schema<T extends SchemaType> {
+    /**
+     * The schema definition.
+     */
+    schema: Schema<T>;
+
+    /**
+     * 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;
+
+    /**
+     * The primary key of the schema.
+     */
+    readonly primaryKey: string;
+
+    /**
+     * The type of the schema.
+     */
+    readonly type: string;
+
+    /**
+     * An optional array of indexes.
+     */
+    /**
+     * 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'] as T['properties'][K]['required'] extends false | (T['properties'][K]['default'] extends undefined ? true: false)  ? K : never]?: T['properties'][K];
+    } & {
+        [K in keyof T['properties'] as T['properties'][K]['required'] extends false ? never : K]: T['properties'][K];
+    };
+    /**
+     * Converts the schema to a JSON representation.
+     *
+     * @returns {SchemaType} The JSON representation of the schema.
+     */
+    toJSON(): SchemaType;
+
+    validate(document: Doc<Schema<T>>): boolean;
+}
+
+
+
+export 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>
+ */
+export 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[] : 
+  never;
+
+export type IsOptional<T> = T extends { required: false } ? true :
+  T extends { default: any } ? true : false;
+
+/**
+ * Doc is a utility type that transforms a schema type into a document type where each property is mapped to its extracted type.
+ *
+ * @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; }
+ */
+export type Doc<T extends SchemaType> = {
+  [K in keyof T["properties"] as IsOptional<T["properties"][K]> extends true ? K : never]?: 
+    ExtractType<T["properties"][K]["type"]>
+} & {
+  [K in keyof T["properties"] as IsOptional<T["properties"][K]> extends false ? K : never]: 
+    ExtractType<T["properties"][K]["type"]>
+} & {
+  __version?: number;
+};
+
+/**
+ * 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.
+ */
+export 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>): Promise<Doc<T>[]>;
+	/**
+	 * count all documents in the collection.
+	 *
+	 * @returns A promise that resolves to an array of documents.
+	 */
+	count(query: QueryType<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 id - The ID of the document to update.
+	 * @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: Doc<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>;
+}
+
+
+
+
+export type EnumerateUpTo<
+    N extends number,
+    Acc extends number[] = []
+> = Acc['length'] extends N ?
+    Acc[number]:
+    EnumerateUpTo<N, [...Acc, Acc['length']]> ;
+
+export type EnumerateFrom1To<
+    N extends number
+> = Exclude<EnumerateUpTo<N>,0> | (N extends 0 ? never : N);
+
+export type IsVersionGreaterThan0<
+    V extends number
+> = V extends 0 ? false : true;
+
+export type AnyVersionGreaterThan1<
+    T extends Record<string, SchemaType>
+> = true extends {
+    [K in keyof T]: IsVersionGreaterThan0<T[K]['version']>;
+} [keyof T] ? true : false;
+
+export type MigrationFunction<T extends SchemaType> = (doc: Doc <T> ) => Doc <T>
+
+export type MigrationPathsForSchema<
+    T extends SchemaType
+> = T['version'] extends 0 ? {}: // No migrations needed for version 1
+    {
+        [K in EnumerateFrom1To < T['version'] > ]: MigrationFunction<T> ;
+    };
+
+export type MigrationPathsForSchemas<
+    T extends SchemaTypeRecord
+> = {
+    [K in keyof T]: MigrationPathsForSchema<T[K]>;
+};
+
+export type MigrationsParameter<
+    T extends SchemaTypeRecord
+> = AnyVersionGreaterThan1<T> extends true ?
+    {
+        migrations: MigrationPathsForSchemas<T>
+    }:
+    {
+        migrations?: never
+    };
+
+
+
+type Hook = (
+    schema: Schema<SchemaType>,
+    migration: MigrationPathsForSchema<SchemaType>,
+    doc: Doc<SchemaType>
+) => Doc<SchemaType>
+
+type BasePluginOptions = {
+    docCreateHook?: Hook,
+    docRecoverHook?: Hook
+}
+
+export class BasePlugin implements BasePluginOptions {
+     docCreateHook?:Hook;
+     docRecoverHook?:Hook;
+}
+
+
+
+/**
+ * Represents an IndexDB storage system extending the base storage functionality.
+ *
+ * @template T - The schema type.
+ */
+export 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
+        >
+    >;
+}
+
+
+
+/**
+ * Represents a record of schema types, where each key is a string and the value is a `SchemaType`.
+ */
+export type SchemaTypeRecord = {
+    [name: string]: SchemaType
+};
+
+export 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]>
+    ): Promise<number>;
+    abstract findDocumentById(
+        collectionName: keyof Schemas, 
+        id: string
+    ): Promise<Doc<Schemas[keyof Schemas]> | undefined | null>;
+    abstract find(
+        collectionName: keyof Schemas, 
+        query: QueryType<Schemas[keyof Schemas]>
+    ): Promise<Doc<Schemas[keyof Schemas]>[]>;
+    abstract write(
+        op: Operation<Schemas[keyof Schemas]>
+    ): Promise<Doc<Schemas[keyof Schemas]>>;
+}
+
+
+/**
+ * Represents a property within a schema, including various constraints and nested properties.
+ */
+export class Property {
+    /**
+     * The type of the property.
+     */
+    readonly type: string;
+
+    /**
+     * 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;
+
+    /**
+     * The maximum number of items for array-type properties, if applicable.
+     */
+    readonly maxItems?: number;
+
+    /**
+     * The minimum number of items for array-type properties, if applicable.
+     */
+    readonly minItems?: number;
+
+    /**
+     * The maximum length for string-type properties, if applicable.
+     */
+    readonly maxLength?: number;
+
+    /**
+     * The minimum length for string-type properties, if applicable.
+     */
+    readonly minLength?: number;
+
+    /**
+     * An optional array of required fields for object-type properties.
+     */
+    readonly required?: boolean;
+
+    /**
+     * 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 an operation to be performed on a collection.
+ *
+ * @template T - The schema type of the collection.
+ */
+export type Operation<T extends 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>,
+
+    /**
+     * An array of indexes related to the operation.
+     */
+    indexes: Array<string>
+}
+
+
+
+export type Operators = {
+    $gte?: number,
+    $gt?: number
+    $lt?: number,
+    $lte?: number
+};
+export type InOperator<T> = {  $in?: T[] };
+export type OperatorOrType<T> = T extends number ? T | Operators | InOperator<T> : T | InOperator<T>;
+export type LogicalOperators<T extends SchemaType> = {
+    $and?: Partial<QueryType<T>>[];
+    $or?: Partial<QueryType<T>>[];
+};
+export type QueryType<T extends SchemaType> = Partial<{
+    [K in keyof T['properties']]: OperatorOrType<
+        ExtractType<
+            T['properties'][K]['type']
+        >
+    >
+}> & LogicalOperators<T> | LogicalOperators<T>[];
+export class Query<T extends SchemaType> {
+    constructor(query: QueryType<T>, schema:Schema<T>)
+    readonly query: QueryType<T>
+}
+//test
+
+
+/**
+* Runtime test harness support instantiated in JS.
+*
+* The node.js entry script instantiates a `Context` here which is used to
+* drive test execution.
+*/
+export class WasmBindgenTestContext {
+  free(): void;
+/**
+* Creates a new context ready to run tests.
+*
+* A `Context` is the main structure through which test execution is
+* coordinated, and this will collect output and results for all executed
+* tests.
+*/
+  constructor();
+/**
+* Inform this context about runtime arguments passed to the test
+* harness.
+* @param {any[]} args
+*/
+  args(args: any[]): void;
+/**
+* Executes a list of tests, returning a promise representing their
+* eventual completion.
+*
+* This is the main entry point for executing tests. All the tests passed
+* in are the JS `Function` object that was plucked off the
+* `WebAssembly.Instance` exports list.
+*
+* The promise returned resolves to either `true` if all tests passed or
+* `false` if at least one test failed.
+* @param {any[]} tests
+* @returns {Promise<any>}
+*/
+  run(tests: any[]): Promise<any>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly corestorage_new: () => number;
+  readonly corestorage_getPrimaryKey: (a: number, b: number, c: number) => void;
+  readonly corestorage_matchesQuery: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_database_free: (a: number) => void;
+  readonly database_start: (a: number) => number;
+  readonly database_close: (a: number) => number;
+  readonly database_started: (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 main_js: () => void;
+  readonly is_debug_mode: () => number;
+  readonly __wbg_corestorage_free: (a: number) => void;
+  readonly __wbg_inmemory_free: (a: number) => void;
+  readonly inmemory_create: (a: number, b: number, c: number) => number;
+  readonly inmemory_by_index: (a: number, b: number) => void;
+  readonly inmemory_write: (a: number, b: number) => number;
+  readonly inmemory_find: (a: number, b: number, c: number, d: number) => number;
+  readonly inmemory_findDocumentById: (a: number, b: number, c: number, d: number) => number;
+  readonly inmemory_count: (a: number, b: number, c: number, d: number) => number;
+  readonly inmemory_close: (a: number) => number;
+  readonly inmemory_start: (a: number) => number;
+  readonly __wbg_basestorage_free: (a: number) => void;
+  readonly basestorage_new: (a: number, b: number, c: number, d: number, e: 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_core: (a: number, b: number) => void;
+  readonly __wbg_schema_free: (a: number) => void;
+  readonly schema_validate: (a: number, b: number, c: number) => void;
+  readonly schema_is_valid: (a: number, b: number) => void;
+  readonly schema_create: (a: number, b: number) => void;
+  readonly schema_version: (a: number) => number;
+  readonly schema_primaryKey: (a: number, b: number) => void;
+  readonly schema_type: (a: number, b: number) => void;
+  readonly schema_indexes: (a: number, b: number) => void;
+  readonly schema_encrypted: (a: number, b: number) => void;
+  readonly schema_properties: (a: number, b: number) => void;
+  readonly __wbgt_test_schema_creation_3: (a: number) => void;
+  readonly __wbgt_test_schema_validation_4: (a: number) => void;
+  readonly __wbgt_test_invalid_schema_5: (a: number) => void;
+  readonly __wbg_collection_free: (a: number) => void;
+  readonly collection_name: (a: number, b: number) => void;
+  readonly collection_schema: (a: number, b: number) => void;
+  readonly collection_find: (a: number, b: number) => number;
+  readonly collection_count: (a: number, b: number) => number;
+  readonly collection_findById: (a: number, b: number) => number;
+  readonly collection_update: (a: number, b: number) => number;
+  readonly collection_create: (a: number, b: number) => number;
+  readonly collection_delete: (a: number, b: number) => number;
+  readonly __wbg_baseplugin_free: (a: number) => void;
+  readonly baseplugin_new: (a: number, b: number, c: number) => void;
+  readonly baseplugin_name: (a: number) => number;
+  readonly baseplugin_get_doc_create_hook: (a: number) => number;
+  readonly baseplugin_get_doc_recover_hook: (a: number) => number;
+  readonly baseplugin_set_doc_create_hook: (a: number, b: number) => void;
+  readonly baseplugin_set_doc_recover_hook: (a: number, b: number) => void;
+  readonly __wbg_indexdb_free: (a: number) => void;
+  readonly indexdb_create: (a: number, b: number, c: number) => number;
+  readonly indexdb_write: (a: number, b: number) => number;
+  readonly indexdb_find: (a: number, b: number, c: number, d: number) => number;
+  readonly indexdb_findDocumentById: (a: number, b: number, c: number, d: number) => number;
+  readonly indexdb_count: (a: number, b: number, c: number, d: number) => number;
+  readonly indexdb_close: (a: number) => number;
+  readonly indexdb_start: (a: number) => number;
+  readonly __wbg_property_free: (a: number) => void;
+  readonly property_is_valid: (a: number, b: number) => void;
+  readonly property_type: (a: number) => number;
+  readonly property_items: (a: number, b: number) => void;
+  readonly property_maxItems: (a: number, b: number) => void;
+  readonly property_minItems: (a: number, b: number) => void;
+  readonly property_maxLength: (a: number, b: number) => void;
+  readonly property_minLength: (a: number, b: number) => void;
+  readonly property_properties: (a: number, b: number) => void;
+  readonly __wbgt_test_property_creation_0: (a: number) => void;
+  readonly __wbgt_test_property_validation_1: (a: number) => void;
+  readonly __wbgt_test_invalid_property_2: (a: number) => void;
+  readonly __wbg_operation_free: (a: number) => void;
+  readonly operation_collection: (a: number, b: number) => void;
+  readonly operation_opType: (a: number) => number;
+  readonly operation_data: (a: number) => number;
+  readonly operation_indexes: (a: number, b: number) => void;
+  readonly __wbg_query_free: (a: number) => void;
+  readonly query_new: (a: number, b: number, c: number) => void;
+  readonly query_query: (a: number, b: number) => void;
+  readonly query_parse: (a: number, b: number) => void;
+  readonly __wbgt_test_query_parse_valid_6: (a: number) => void;
+  readonly __wbgt_test_query_parse_invalid_property_7: (a: number) => void;
+  readonly __wbgt_test_query_parse_invalid_type_8: (a: number) => void;
+  readonly __wbgt_test_query_parse_logical_operators_9: (a: number) => void;
+  readonly __wbgt_test_query_parse_invalid_operator_10: (a: number) => void;
+  readonly __wbgt_test_query_parse_operator_wrong_type_11: (a: number) => void;
+  readonly __wbgt_test_query_parse_in_operator_12: (a: number) => void;
+  readonly __wbgt_test_query_parse_in_operator_wrong_type_13: (a: number) => void;
+  readonly __wbgt_test_query_get_query_normalization_simple_attributes_14: (a: number) => void;
+  readonly __wbgt_test_query_get_query_normalization_with_logical_operator_15: (a: number) => void;
+  readonly __wbgt_test_query_get_query_normalization_nested_logical_operators_16: (a: number) => void;
+  readonly __wbgt_test_query_get_query_normalization_only_logical_operator_17: (a: number) => void;
+  readonly __wbgt_test_query_get_query_normalization_complex_mixed_18: (a: number) => void;
+  readonly __wbgt_test_query_parse_empty_query_19: (a: number) => void;
+  readonly __wbgt_test_query_parse_non_object_query_20: (a: number) => void;
+  readonly __wbgt_test_query_parse_multiple_operators_21: (a: number) => void;
+  readonly __wbgt_test_query_parse_invalid_in_operator_22: (a: number) => void;
+  readonly __wbgt_test_query_parse_empty_logical_operators_23: (a: number) => void;
+  readonly __wbg_wasmbindgentestcontext_free: (a: number) => void;
+  readonly wasmbindgentestcontext_new: () => number;
+  readonly wasmbindgentestcontext_args: (a: number, b: number, c: number) => void;
+  readonly wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
+  readonly __wbgtest_console_log: (a: number) => void;
+  readonly __wbgtest_console_debug: (a: number) => void;
+  readonly __wbgtest_console_info: (a: number) => void;
+  readonly __wbgtest_console_warn: (a: number) => void;
+  readonly __wbgtest_console_error: (a: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4279c525cebb26f2: (a: number, b: number, c: number) => void;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h8fc6c6f4e4fe440c: (a: number, b: number, c: number) => number;
+  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__h80335dc7fe1c3f7e: (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__ha1155a5e1cc6e1e8: (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__h19fc1620bec787be: (a: number, b: number) => void;
+  readonly wasm_bindgen__convert__closures__invoke3_mut__h7b738c7e28e951e8: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly wasm_bindgen__convert__closures__invoke2_mut__h3a3f5f08be32a04a: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise<InitInput>} module_or_path
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;