@medyll/idae-machine 0.129.0 → 0.135.2

package/dist/main/machine/{IDbCollectionValues.js → MachineSchemeValues.js}

@@ -1,51 +1,43 @@
 import { MachineDb } from '../machineDb.js';
-import {} from '../machineForge.js';
-import { IDbError } from './IDbError.js';
+import { MachineError } from './MachineError.js';
+import { SchemeFieldDefaultValues } from './SchemeFieldDefaultValues.js';
 /**
- * IDbCollectionValues
- *
- * This class provides utilities to display, format, and introspect field values for a given collection, using the schema and provided data.
- * It is designed for dynamic UI rendering, presentation logic, and metadata extraction for form generation in schema-driven applications.
- *
- * Main responsibilities:
- * - Holds a reference to the collection name and the schema (IDbBase).
- * - Provides methods to format field values according to their type (number, text, array, object, etc.).
- * - Supplies presentation logic for displaying records (e.g., presentation string, index value).
- * - Offers input attribute generation for forms (inputDataSet).
- * - Supports iteration over array/object fields for advanced UI layouts.
- * - Enables access to field metadata for validation and rendering.
- *
- * Usage:
- *   const values = new IDbCollectionValues('agents');
- *   const display = values.presentation(agentData); // formatted display string
- *   const index = values.indexValue(agentData); // index field value
- *   const formatted = values.format('name', agentData); // formatted field value
- *   const attrs = values.getInputDataSet('name', agentData); // input attributes for forms
+ * @class MachineSchemeValues
+ * @role Provides utilities to display, format, and introspect field values for a given collection, using the schema and provided data.
  *
  * This class is typically used via IDbBase.getCollectionValues for shared instance management.
- * @template T - The type of the data object for the collection.
+ *
+ * @template T The type of the data object for the collection.
  */
-export class IDbCollectionValues {
+export class MachineSchemeValues {
     /**
      * The IDbBase instance used for schema introspection.
      */
-    idbBase;
+    machine;
     /**
      * The collection name this instance operates on.
      */
     collectionName;
     /**
      * Create a new IDbCollectionValues instance for a given collection.
-     * @param collectionName The collection name.
+     * @role Constructor
+     * @param {TplCollectionName} collectionName The collection name.
+     * @param {MachineDb} machine The MachineDb instance.
      */
-    constructor(collectionName, idbBase) {
+    constructor(collectionName, machine) {
         this.collectionName = collectionName;
-        this.idbBase = idbBase ?? new MachineDb();
+        this.machine = machine;
     }
+    /**
+     * Get the presentation string for a data object, using the collection's presentation template.
+     * @role Presentation logic
+     * @param {Record<string, any>} data The data object.
+     * @return {string} The formatted presentation string.
+     */
     presentation(data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const presentation = this.idbBase.collection(this.collectionName).getPresentation();
+            const presentation = this.machine.collection(this.collectionName).template.presentation;
             this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
             const fields = presentation.split(' ');
             return fields
@@ -56,7 +48,7 @@ export class IDbCollectionValues {
                 .join(' ');
         }
         catch (error) {
-            IDbError.handleError(error);
+            MachineError.handleError(error);
             return '';
         }
     }
@@ -65,16 +57,22 @@ export class IDbCollectionValues {
      * @param data The data object.
      * @returns The value of the index field, or null if not found.
      */
+    /**
+     * Get the value of the index field for a data object.
+     * @role Index accessor
+     * @param {Record<string, any>} data The data object.
+     * @return {any | null} The value of the index field, or null if not found.
+     */
     indexValue(data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const indexName = this.idbBase.collection(this.collectionName).getIndexName();
+            const indexName = this.machine.collection(this.collectionName).template.index;
             this.#checkError(!indexName, 'Index not found for collection', 'INDEX_NOT_FOUND');
             this.#checkError(!(indexName in data), `Index field ${indexName} not found in data`, 'FIELD_NOT_FOUND');
             return data[indexName];
         }
         catch (error) {
-            IDbError.handleError(error);
+            MachineError.handleError(error);
             return null;
         }
     }
@@ -84,13 +82,23 @@ export class IDbCollectionValues {
      * @param data The data object.
      * @returns The formatted value as a string.
      */
+    /**
+     * Format a field value for display, using the field type and schema.
+     * @role Field formatting
+     * @param {keyof T} fieldName The field name.
+     * @param {T} data The data object.
+     * @return {string} The formatted value as a string.
+     */
     format(fieldName, data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
             this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
-            const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+            const fieldInfo = this.machine.collection(this.collectionName).field(String(fieldName)).parse();
             this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
-            switch (fieldInfo?.fieldType) {
+            if (!fieldInfo) {
+                return String(data[fieldName]);
+            }
+            switch (fieldInfo.fieldType) {
                 case 'number':
                     return this.#formatNumberField(data[fieldName]);
                 case 'text':
@@ -105,7 +113,7 @@ export class IDbCollectionValues {
             }
         }
         catch (error) {
-            IDbError.handleError(error);
+            MachineError.handleError(error);
             return '';
         }
     }
@@ -115,11 +123,18 @@ export class IDbCollectionValues {
      * @param data The data object.
      * @returns An object with data-* attributes for the field.
      */
+    /**
+     * Get a set of data-* attributes for a field, for use in form generation or UI.
+     * @role Input attribute generation
+     * @param {string} fieldName The field name.
+     * @param {T} data The data object.
+     * @return {Record<`data-${'collection' | 'collectionId' | 'fieldName' | 'fieldType' | 'fieldArgs'}`, string>} The data-* attributes for the field.
+     */
     getInputDataSet(fieldName, data) {
-        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        const fieldInfo = this.machine.collection(this.collectionName).field(fieldName).parse();
         const fieldType = fieldInfo?.fieldType ?? '';
         const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
-        const indexName = this.idbBase.collection(this.collectionName).getIndexName();
+        const indexName = this.machine.collection(this.collectionName).template.index;
         return {
             'data-collection': this.collectionName,
             'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
@@ -134,12 +149,25 @@ export class IDbCollectionValues {
      * @param data The array data.
      * @returns An array of IDbForge objects.
      */
+    /**
+     * Iterate over an array field and return an array of IDbForge objects for each element.
+     * @role Array field iteration
+     * @param {keyof TplFields} fieldName The field name.
+     * @param {any[]} data The array data.
+     * @return {IDbForge[]} An array of IDbForge objects.
+     */
+    // NOTE: Return type is any[] to match actual runtime type from parser (fieldArgs may be string)
+    // TODO: Refine IDbForge type if needed for stricter typing
     iterateArrayField(fieldName, data) {
-        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        const fieldInfo = this.machine.collection(this.collectionName).field(fieldName).parse();
         if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
             return [];
         }
-        return data.map((_, idx) => ({ ...fieldInfo, fieldName: `${String(fieldName)}[${idx}]` }));
+        return data
+            .map((_, idx) => fieldInfo && fieldInfo.fieldType
+            ? { ...fieldInfo, fieldName: `${String(fieldName)}[${idx}]`, collection: this.collectionName }
+            : undefined)
+            .filter(Boolean);
     }
     /**
      * Iterate over an object field and return an array of IDbForge objects for each property.
@@ -147,18 +175,37 @@ export class IDbCollectionValues {
      * @param data The object data.
      * @returns An array of IDbForge objects.
      */
+    /**
+     * Iterate over an object field and return an array of IDbForge objects for each property.
+     * @role Object field iteration
+     * @param {keyof TplFields} fieldName The field name.
+     * @param {Record<string, unknown>} data The object data.
+     * @return {IDbForge[]} An array of IDbForge objects.
+     */
+    // NOTE: Return type is any[] to match actual runtime type from parser (fieldArgs may be string)
+    // TODO: Refine IDbForge type if needed for stricter typing
     iterateObjectField(fieldName, data) {
-        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        const fieldInfo = this.machine.collection(this.collectionName).field(fieldName).parse();
         if (fieldInfo?.is !== 'object' || typeof data !== 'object' || data === null) {
             return [];
         }
-        return Object.keys(data).map((key) => ({ ...fieldInfo, fieldName: `${String(fieldName)}.${key}` }));
+        return Object.keys(data)
+            .map((key) => fieldInfo && fieldInfo.fieldType
+            ? { ...fieldInfo, fieldName: `${String(fieldName)}.${key}`, collection: this.collectionName }
+            : undefined)
+            .filter(Boolean);
     }
     /**
      * Internal: Format a number field for display.
      * @param value The number value.
      * @returns The formatted string.
      */
+    /**
+     * Internal: Format a number field for display.
+     * @role Number formatting
+     * @param {number} value The number value.
+     * @return {string} The formatted string.
+     */
     #formatNumberField(value) {
         // Implement number formatting logic here
         return value.toString();
@@ -169,6 +216,13 @@ export class IDbCollectionValues {
      * @param type The text type (e.g. 'text-short').
      * @returns The formatted string.
      */
+    /**
+     * Internal: Format a text field for display, with length limits by type.
+     * @role Text formatting
+     * @param {unknown} value The string value.
+     * @param {string} type The text type (e.g. 'text-short').
+     * @return {string} The formatted string.
+     */
     #formatTextField(value, type) {
         const lengths = {
             'text-tiny': 10,
@@ -185,6 +239,11 @@ export class IDbCollectionValues {
      * Internal: Check if access is allowed (override for custom logic).
      * @returns True if access is allowed.
      */
+    /**
+     * Internal: Check if access is allowed (override for custom logic).
+     * @role Access check
+     * @return {boolean} True if access is allowed.
+     */
     #checkAccess() {
         // Implement access check logic here
         return true;
@@ -195,9 +254,25 @@ export class IDbCollectionValues {
      * @param message The error message.
      * @param code The error code.
      */
+    /**
+     * Internal: Throw an error if a condition is met.
+     * @role Error handling
+     * @param {boolean} condition The condition to check.
+     * @param {string} message The error message.
+     * @param {string} code The error code.
+     */
     #checkError(condition, message, code) {
         if (condition) {
-            IDbError.throwError(message, code);
+            MachineError.throwError(message, code);
         }
     }
+    /**
+     * Get default values for the collection, using global and collection-specific factories.
+     * @role Default values
+     * @returns {Record<string, any>} An object with default values for each field in the collection.
+     */
+    getDefaults() {
+        const fields = Object.keys(this.machine.collection(this.collectionName).template.fields || {});
+        return SchemeFieldDefaultValues.getDefaults(fields, this.collectionName);
+    }
 }

package/dist/main/machine/SchemeFieldDefaultValues.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Example: Using SchemeFieldDefaultValues to get default values for a collection
+ *
+ * import { SchemeFieldDefaultValues } from './SchemeFieldDefaultValues';
+ *
+ * // For a collection 'agents' with fields ['name', 'role', 'createdAt']
+ * const defaults = SchemeFieldDefaultValues.getDefaults(['name', 'role', 'createdAt'], 'agents');
+ * // defaults = { name: ..., role: ..., createdAt: ... }
+ *
+ * // In a Svelte form (pseudo-code):
+ * let formData = { ...SchemeFieldDefaultValues.getDefaults(Object.keys(formFields), collection) };
+ *
+ * // When rendering the form, fields with no user value will use the default
+ * <input name="name" bind:value={formData.name} />
+ * <input name="role" bind:value={formData.role} />
+ * <input name="createdAt" bind:value={formData.createdAt} />
+ *
+ * // To set or override a default globally:
+ * SchemeFieldDefaultValues.setDefault('role', () => 'admin');
+ *
+ * // To set a default for a specific collection:
+ * SchemeFieldDefaultValues.setDefault('role', () => 'user', 'agents');
+ *
+ * // To set multiple defaults at once:
+ * SchemeFieldDefaultValues.setDefaults({ status: () => 'active', country: () => 'FR' });
+ *
+ * // To set multiple defaults for a collection:
+ * SchemeFieldDefaultValues.setDefaults({ status: () => 'pending' }, 'orders');
+ */
+import type { TplCollectionName } from "@medyll/idae-idbql";
+export declare class SchemeFieldDefaultValues {
+    /**
+     * Default value factories for all collections (global fields).
+     * Each key is a field name, value is a function returning the default value.
+     * @type {Record<string, () => any>}
+     */
+    static defaultFieldFactories: Record<string, () => any>;
+    /**
+     * Default value factories per collection.
+     * Each key is a collection name, value is an object of field factories.
+     * @type {Record<string, Record<string, () => any>>}
+     */
+    static defaultCollectionFactories: Record<string, Record<string, () => any>>;
+    /**
+     * Add or update a default value factory for a single field (global or collection-specific).
+     * @param {string} field - The field name.
+     * @param {() => any} factory - The factory function.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific default.
+     */
+    static setDefault(field: string, factory: () => any, collectionName?: TplCollectionName): void;
+    /**
+     * Add or update multiple default value factories at once (global or collection-specific).
+     * @param {Record<string, () => any>} factories - Object of field:factory pairs.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific defaults.
+     */
+    static setDefaults(factories: Record<string, () => any>, collectionName?: TplCollectionName): void;
+    /**
+     * Get default values for a set of fields, using global and optionally collection-specific factories.
+     * If collectionName is provided, collection-specific factories take priority over global ones.
+     * If not, only global defaults are used.
+     *
+     * @param {string[]} fields - The list of field names.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific defaults.
+     * @returns {Record<string, any>} An object with default values for each field.
+     */
+    static getDefaults(fields: string[], collectionName?: TplCollectionName): Record<string, any>;
+    /**
+     * Get the default value for a single field, using collection-specific or global factory.
+     * @param {string} field - The field name.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific default.
+     * @returns {any} The default value for the field, or undefined if none.
+     */
+    static getDefault(field: string, collectionName?: TplCollectionName): any;
+}

package/dist/main/machine/SchemeFieldDefaultValues.js

@@ -0,0 +1,98 @@
+// Example: How to use SchemeFieldDefaultValues in a Svelte form
+// (for documentation/demo, not for direct import)
+// Single class declaration with all static methods and properties
+export class SchemeFieldDefaultValues {
+    /**
+     * Default value factories for all collections (global fields).
+     * Each key is a field name, value is a function returning the default value.
+     * @type {Record<string, () => any>}
+     */
+    static defaultFieldFactories = {
+        createdAt: () => new Date(),
+        updatedAt: () => new Date(),
+        status: () => "draft",
+        // Add more global defaults here
+    };
+    /**
+     * Default value factories per collection.
+     * Each key is a collection name, value is an object of field factories.
+     * @type {Record<string, Record<string, () => any>>}
+     */
+    static defaultCollectionFactories = {
+    // Example:
+    // agents: {
+    //   role: () => "user",
+    // },
+    };
+    /**
+     * Add or update a default value factory for a single field (global or collection-specific).
+     * @param {string} field - The field name.
+     * @param {() => any} factory - The factory function.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific default.
+     */
+    static setDefault(field, factory, collectionName) {
+        if (collectionName) {
+            if (!this.defaultCollectionFactories[collectionName]) {
+                this.defaultCollectionFactories[collectionName] = {};
+            }
+            this.defaultCollectionFactories[collectionName][field] = factory;
+        }
+        else {
+            this.defaultFieldFactories[field] = factory;
+        }
+    }
+    /**
+     * Add or update multiple default value factories at once (global or collection-specific).
+     * @param {Record<string, () => any>} factories - Object of field:factory pairs.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific defaults.
+     */
+    static setDefaults(factories, collectionName) {
+        if (collectionName) {
+            if (!this.defaultCollectionFactories[collectionName]) {
+                this.defaultCollectionFactories[collectionName] = {};
+            }
+            Object.assign(this.defaultCollectionFactories[collectionName], factories);
+        }
+        else {
+            Object.assign(this.defaultFieldFactories, factories);
+        }
+    }
+    /**
+     * Get default values for a set of fields, using global and optionally collection-specific factories.
+     * If collectionName is provided, collection-specific factories take priority over global ones.
+     * If not, only global defaults are used.
+     *
+     * @param {string[]} fields - The list of field names.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific defaults.
+     * @returns {Record<string, any>} An object with default values for each field.
+     */
+    static getDefaults(fields, collectionName) {
+        const result = {};
+        const collectionDefaults = collectionName ? (this.defaultCollectionFactories[collectionName] || {}) : {};
+        for (const field of fields) {
+            if (collectionDefaults[field]) {
+                result[field] = collectionDefaults[field]();
+            }
+            else if (this.defaultFieldFactories[field]) {
+                result[field] = this.defaultFieldFactories[field]();
+            }
+            // else: no default
+        }
+        return result;
+    }
+    /**
+     * Get the default value for a single field, using collection-specific or global factory.
+     * @param {string} field - The field name.
+     * @param {TplCollectionName} [collectionName] - Optional collection name for specific default.
+     * @returns {any} The default value for the field, or undefined if none.
+     */
+    static getDefault(field, collectionName) {
+        if (collectionName && this.defaultCollectionFactories[collectionName]?.[field]) {
+            return this.defaultCollectionFactories[collectionName][field]();
+        }
+        if (this.defaultFieldFactories[field]) {
+            return this.defaultFieldFactories[field]();
+        }
+        return undefined;
+    }
+}

package/dist/main/machine.d.ts

@@ -1,33 +1,8 @@
+import { MachineDb } from "./machineDb.js";
+import { createIdbqDb, type IdbqModel } from "@medyll/idae-idbql";
 /**
- * Example usage:
- *
- * import { Machine } from './machine.js';
- *
- * // Create a new Machine instance with default parameters
- * const machine = new Machine( 'example-db', 1, { collections: {} });
- *
- * // Start the machine (initialize collections and IDBQL connection)
- * machine.start();
- *
- * // Access collections (schema logic)
- * const collections = machine.collections;
- *
- * // Access IDBQL (readonly)
- * const idbql = machine.idbql;
- *
- * // Access IDBQL (stateful)
- * const idbqlState = machine.idbqlState;
- *
- * // Access IndexedDB core
- * const db = machine.indexedb;
- *
- * // Access the IDBQL data model
- * const model = machine.idbqModel;
- */
-import { MachineDb } from './machineDb.js';
-import { createIdbqDb, type IdbqModel } from '@medyll/idae-idbql';
-/**
- * Machine: main entry point for managing the IDBQL connection and centralized data access.
+ * @class Machine
+ * @role Main entry point for managing the IDBQL connection and centralized data access.
  */
 export declare class Machine {
     /**
@@ -49,7 +24,7 @@ export declare class Machine {
     /**
      * Centralized access to schema and collection logic
      */
-    _idbbase: MachineDb;
+    _machineDb: MachineDb;
     /**
      * Database name
      */
@@ -64,43 +39,95 @@ export declare class Machine {
     _model: IdbqModel;
     /**
      * Main constructor
+     * @role Constructor
+     * @param {string=} dbName The name of the database.
+     * @param {number=} version The schema version number.
+     * @param {IdbqModel=} model The IDBQL data model.
      */
     constructor(dbName?: string, version?: number, model?: IdbqModel);
+    /**
+     * Initialize the machine with configuration parameters.
+     * @role Initializer
+     * @param {{ dbName?: string; version?: number; model: IdbqModel }} [options] Optional parameters to set dbName, version, and model.
+     * @return {void}
+     */
     init(options?: {
         dbName?: string;
         version?: number;
-        model?: IdbqModel;
+        model: IdbqModel;
     }): void;
     /**
-     * Start the machine: initialize collections and IDBQL connection.
+     * Start the machine: initializes collections and the IDBQL connection.
+     * Call this after constructing the Machine to set up the database and collections.
+     * @role Initializer
+     * @return {void}
      */
     start(): void;
+    /**
+     * Internal: Creates the collections logic using the provided data model.
+     * Throws an error if the model is not defined.
+     * @role Internal
+     * @private
+     * @return {void}
+     */
     private createCollections;
+    /**
+     * Internal: Creates the IDBQL store and initializes database connections.
+     * Throws an error if model, dbName, or version is missing.
+     * @role Internal
+     * @private
+     * @return {void}
+     */
     private createStore;
     /**
-     * Get the IDbBase (schema logic) instance
+     * Get the MachineDb (schema logic) instance.
+     * @role Accessor
+     * @deprecated Use logic instead.
+     * @return {MachineDb} The schema and collection logic instance.
      */
     get collections(): MachineDb;
     /**
-     * IDBQL (readonly) instance
+     * Get the IDbBase (schema logic) instance.
+     * Recommended accessor for schema and collection logic.
+     * @role Accessor
+     * @return {MachineDb} The schema and collection logic instance.
+     */
+    get logic(): MachineDb;
+    /**
+     * Get the IDBQL (readonly) instance.
+     * Use for read-only access to collections.
+     * @role Accessor
+     * @return {ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbql"] | undefined} The readonly IDBQL instance.
      */
-    get idbql(): import("@medyll/idae-idbql").ReadonlyCollections<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    get idbql(): ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbql"] | undefined;
     /**
-     * IDBQL (stateful) instance , old name was idbqlState => store
+     * Get the IDBQL (stateful) instance.
+     * Previously called idbqlState; use for stateful operations.
+     * @role Accessor
+     * @return {ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"]} The stateful IDBQL instance.
      */
-    get store(): import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>>;
+    get store(): ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"];
     /**
-     * Direct getter for idbqlState (for test compatibility)
+     * Direct getter for idbqlState (for test compatibility).
+     * Returns the stateful IDBQL instance.
+     * @role Accessor
+     * @deprecated Use store instead.
+     * @return {ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"]} The stateful IDBQL instance.
      */
-    get idbqlState(): import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>>;
+    get idbqlState(): ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"];
     /**
-     * IndexedDB (core) instance
-     * @deprecated
+     * Get the IndexedDB (core) instance.
+     * @role Accessor
+     * @deprecated Use IDBQL accessors instead.
+     * @return {ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbDatabase"] | undefined} The IndexedDB instance.
      */
-    get indexedb(): import("@medyll/idae-idbql").IdbqlIndexedCore<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    get indexedb(): ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbDatabase"] | undefined;
     /**
-     * IDBQL data model instance
+     * Get the IDBQL data model instance.
+     * Returns the current IDBQL model used by the machine.
+     * @role Accessor
+     * @return {ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqModel"] | undefined} The IDBQL model instance.
      */
-    get idbqModel(): IdbqModel<Record<string, Record<string, any>>> | undefined;
+    get idbqModel(): ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqModel"] | undefined;
 }
 export declare const machine: Machine;