@medyll/idae-machine 0.129.0 → 0.135.2

package/dist/main/machine.js

@@ -1,33 +1,8 @@
+import { MachineDb } from "./machineDb.js";
+import { createIdbqDb } 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 } 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 class Machine {
     /**
@@ -49,7 +24,7 @@ export class Machine {
     /**
      * Centralized access to schema and collection logic
      */
-    _idbbase;
+    _machineDb;
     /**
      * Database name
      */
@@ -64,33 +39,60 @@ export class Machine {
     _model;
     /**
      * 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, version, model) {
-        this._dbName = dbName ?? '';
+        this._dbName = dbName ?? "";
         this._version = version ?? 1;
         this._model = model ?? undefined;
     }
+    /**
+     * 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) {
         this._dbName = options?.dbName ?? this._dbName;
         this._version = options?.version ?? this._version;
         this._model = options?.model ?? this._model;
     }
     /**
-     * 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() {
         this.createCollections();
         this.createStore();
     }
+    /**
+     * Internal: Creates the collections logic using the provided data model.
+     * Throws an error if the model is not defined.
+     * @role Internal
+     * @private
+     * @return {void}
+     */
     createCollections() {
         if (!this._model) {
-            throw new Error('Data model is not defined');
+            throw new Error("Data model is not defined");
         }
-        this._idbbase = new MachineDb(this._model);
+        this._machineDb = new MachineDb(this._model);
     }
+    /**
+     * Internal: Creates the IDBQL store and initializes database connections.
+     * Throws an error if model, dbName, or version is missing.
+     * @role Internal
+     * @private
+     * @return {void}
+     */
     createStore() {
         if (!this._model || !this._dbName || !this._version) {
-            throw new Error('Model, dbName, or version is not defined');
+            throw new Error("Model, dbName, or version is not defined");
         }
         const idbqStore = createIdbqDb(this._model, this._version);
         const { idbql, idbqlState, idbDatabase, idbqModel } = idbqStore.create(this._dbName);
@@ -98,40 +100,69 @@ export class Machine {
         this._idbqlState = idbqlState;
         this._idbDatabase = idbDatabase;
         this._idbqModel = idbqModel;
+        console.log("Machine started with DB:", this._dbName, "Version:", this._version);
+        console.log("IDBQL State Instance:", this._idbqlState);
     }
     /**
-     * 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() {
-        return this._idbbase;
+        return this._machineDb;
+    }
+    /**
+     * 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() {
+        return this._machineDb;
     }
     /**
-     * IDBQL (readonly) instance
+     * 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() {
         return this._idbql;
     }
     /**
-     * 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() {
         return this._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() {
         return this._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() {
         return this._idbDatabase;
     }
     /**
-     * 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() {
         return this._idbqModel;

package/dist/main/machineDb.d.ts

@@ -1,42 +1,9 @@
-import type { IdbqModel, TplCollectionName, Tpl, TplFields } from "@medyll/idae-idbql";
-import { IDbCollection } from "./machine/IDbCollection.js";
-import type { IDbForge } from "./machineForge.js";
-import { MachineForge } from "./machineForge.js";
-export declare enum enumPrimitive {
-    id = "id",
-    any = "any",
-    date = "date",
-    datetime = "datetime",
-    time = "time",
-    text = "text",
-    number = "number",
-    boolean = "boolean",
-    url = "url",
-    email = "email",
-    phone = "phone",
-    password = "password"
-}
-export declare enum TplProperties {
-    "private" = "private",
-    "readonly" = "readonly",
-    "required" = "required"
-}
-type CombineElements<T extends string, U extends string = T> = T extends any ? T | `${T} ${CombineElements<Exclude<U, T>>}` : never;
-type CombinedArgs = CombineElements<TplProperties>;
-type IdbObjectify<T extends string = "number"> = `array-of-${T}` | `object-${T}`;
-export type IdDbPrimitive<T = {}> = keyof typeof enumPrimitive | `text-${"tiny" | "short" | "medium" | "long" | "area"}` | `${string}.${string}` | `fk-${string}.${string}`;
-export type IDbObjectPrimitive = IdbObjectify<IdDbPrimitive>;
-export type IDbFk = `fk-${string}.${string}`;
-export type IDbFkObject = IdbObjectify<IDbFk>;
-export type IDbTypes = IdDbPrimitive | IDbObjectPrimitive | IDbFk | IDbFkObject;
-export type IDBArgumentsTypes = `${IDbTypes}(${CombinedArgs})`;
-export type IDbFieldRules = IDBArgumentsTypes | IDbTypes;
-export type IDbFieldType = IDBArgumentsTypes | IDbTypes;
-export type IDbForgeArgs = keyof typeof TplProperties;
+import type { IdbqModel, TplCollectionName } from "@medyll/idae-idbql";
+import { MachineScheme } from "./machine/MachineScheme.js";
+import { MachineParserForge } from "./machineParserForge.js";
 /**
- * Central class for parsing, introspecting, and extracting metadata from the database schema.
- * Provides methods to access collections, templates, fields, foreign keys, and type information.
- * Used for dynamic UI generation, validation, and schema-driven logic.
+ * @class MachineDb
+ * @role Central class for parsing, introspecting, and extracting metadata from the database schema. Provides methods to access collections, templates, fields, foreign keys, and type information. Used for dynamic UI generation, validation, and schema-driven logic.
  */
 export declare class MachineDb {
     #private;
@@ -44,27 +11,18 @@ export declare class MachineDb {
      * The database model (schema) used for introspection.
      */
     model: IdbqModel;
-    machineForge: MachineForge;
+    machineForge: MachineParserForge;
     /**
-     * Create a new IDbBase instance.
-     * @param model Optional custom model to use (default: schemeModel)
+     * Create a new MachineDb instance.
+     * @role Constructor
+     * @param {IdbqModel} model Custom model to use.
      */
-    constructor(model?: IdbqModel);
+    constructor(model: IdbqModel);
     /**
      * Get an IDbCollection instance for a collection name.
+     * @role Collection accessor
+     * @param {TplCollectionName} collection The collection name.
+     * @return {MachineScheme} The IDbCollection instance.
      */
-    collection(collection: TplCollectionName): IDbCollection;
-    fks(collection: string): {
-        [collection: string]: Tpl;
-    };
-    reverseFks(targetCollection: TplCollectionName): Record<string, any>;
-    /**
-     * Parse all fields of a given collection.
-     */
-    parseRawCollection(collection: TplCollectionName): Record<string, IDbForge | undefined> | undefined;
-    /**
-     * Parse a single field of a collection and return its IDbForge metadata.
-     */
-    parseCollectionFieldName(collection: TplCollectionName, fieldName: keyof TplFields): IDbForge | undefined;
+    collection(collection: TplCollectionName): MachineScheme;
 }
-export {};

package/dist/main/machineDb.js

@@ -1,118 +1,35 @@
-/*
-    path: D:\boulot\python\wollama\src\lib\db\dbFields.ts
- */
-import { schemeModelDb } from "../db/dbSchema.js";
-import { IDbCollection } from "./machine/IDbCollection.js";
-import { IDbError } from "./machine/IDbError.js";
-import { MachineForge } from "./machineForge.js";
-export var enumPrimitive;
-(function (enumPrimitive) {
-    enumPrimitive["id"] = "id";
-    enumPrimitive["any"] = "any";
-    enumPrimitive["date"] = "date";
-    enumPrimitive["datetime"] = "datetime";
-    enumPrimitive["time"] = "time";
-    enumPrimitive["text"] = "text";
-    enumPrimitive["number"] = "number";
-    enumPrimitive["boolean"] = "boolean";
-    enumPrimitive["url"] = "url";
-    enumPrimitive["email"] = "email";
-    enumPrimitive["phone"] = "phone";
-    enumPrimitive["password"] = "password";
-})(enumPrimitive || (enumPrimitive = {}));
-export var TplProperties;
-(function (TplProperties) {
-    TplProperties["private"] = "private";
-    TplProperties["readonly"] = "readonly";
-    TplProperties["required"] = "required";
-})(TplProperties || (TplProperties = {}));
-const a = "any(private required readonly)";
+import { MachineScheme } from "./machine/MachineScheme.js";
+import { MachineParserForge } from "./machineParserForge.js";
 /**
- * Central class for parsing, introspecting, and extracting metadata from the database schema.
- * Provides methods to access collections, templates, fields, foreign keys, and type information.
- * Used for dynamic UI generation, validation, and schema-driven logic.
+ * @class MachineDb
+ * @role Central class for parsing, introspecting, and extracting metadata from the database schema. Provides methods to access collections, templates, fields, foreign keys, and type information. Used for dynamic UI generation, validation, and schema-driven logic.
  */
 export class MachineDb {
     /**
      * The database model (schema) used for introspection.
      */
-    model = schemeModelDb;
-    machineForge = new MachineForge();
+    model;
+    machineForge = new MachineParserForge();
     #idbCollectionsList = {};
     /**
-     * Create a new IDbBase instance.
-     * @param model Optional custom model to use (default: schemeModel)
+     * Create a new MachineDb instance.
+     * @role Constructor
+     * @param {IdbqModel} model Custom model to use.
      */
     constructor(model) {
-        this.model = model ?? schemeModelDb;
-        this.machineForge = new MachineForge();
+        this.model = model;
+        this.machineForge = new MachineParserForge();
     }
     /**
      * Get an IDbCollection instance for a collection name.
+     * @role Collection accessor
+     * @param {TplCollectionName} collection The collection name.
+     * @return {MachineScheme} The IDbCollection instance.
      */
     collection(collection) {
         if (!this.#idbCollectionsList[collection]) {
-            this.#idbCollectionsList[collection] = new IDbCollection(collection, this, this.model);
+            this.#idbCollectionsList[collection] = new MachineScheme(collection, this, this.model);
         }
         return this.#idbCollectionsList[collection];
     }
-    fks(collection) {
-        const fks = this.collection(collection).getModelTemplateFks();
-        const out = {};
-        if (fks) {
-            Object.keys(fks).forEach((collection) => {
-                out[collection] = this.parseRawCollection(collection);
-            });
-        }
-        return out;
-    }
-    reverseFks(targetCollection) {
-        const result = {};
-        Object.entries(this.model).forEach(([collectionName, collectionModel]) => {
-            const template = collectionModel.template;
-            if (template && template.fks) {
-                Object.entries(template.fks).forEach(([fkName, fkConfig]) => {
-                    if (fkConfig?.code === targetCollection) {
-                        if (!result[collectionName]) {
-                            result[collectionName] = {};
-                        }
-                        result[collectionName][fkName] = fkConfig;
-                    }
-                });
-            }
-        });
-        return result;
-    }
-    /**
-     * Parse all fields of a given collection.
-     */
-    parseRawCollection(collection) {
-        const fields = new IDbCollection(collection, this, this.model).fields;
-        if (!fields)
-            return;
-        const out = {};
-        Object.keys(fields).forEach((fieldName) => {
-            const fieldType = fields[fieldName];
-            if (fieldType) {
-                out[fieldName] = this.parseCollectionFieldName(collection, fieldName);
-            }
-        });
-        return out;
-    }
-    /**
-     * Parse a single field of a collection and return its IDbForge metadata.
-     */
-    parseCollectionFieldName(collection, fieldName) {
-        const field = this.collection(collection).getFieldRule(fieldName);
-        if (!field) {
-            IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, "FIELD_NOT_FOUND");
-            return undefined;
-        }
-        const array = this.machineForge.testIs("array", field);
-        const object = this.machineForge.testIs("object", field);
-        const fk = this.machineForge.testIs("fk", field);
-        const primitive = this.machineForge.testIs("primitive", field);
-        const fieldType = array ?? object ?? fk ?? primitive;
-        return this.machineForge.forge({ collection, fieldName, ...fieldType });
-    }
 }

package/dist/main/{machineForge.d.ts → machineParserForge.d.ts}

@@ -1,30 +1,20 @@
-import type { TplCollectionName, TplFields } from "@medyll/idae-idbql";
-import type { IDbFieldType, IDbFieldRules, IDbForgeArgs } from "./machineDb.js";
-/**
- * Represents the structure for database field forging.
- * Used to describe and construct database field definitions dynamically.
- */
-export type IDbForge = {
-    /** Name of the collection (table) */
-    collection?: TplCollectionName;
-    /** Name of the field within the collection */
-    fieldName?: keyof TplFields;
-    /** Type of the field (e.g., string, number, fk, array, etc.) */
-    fieldType?: IDbFieldType;
-    /** Field rule string describing the type and constraints */
-    fieldRule?: IDbFieldRules;
-    /** Additional arguments for the field (properties, options, etc.) */
-    fieldArgs?: IDbForgeArgs | undefined;
-    /** The resolved type (array, object, fk, primitive) */
-    is: unknown;
-};
+import type { TplCollectionName, TplFieldRules, TplFieldType, TplFieldArgs } from "@medyll/idae-idbql";
 /**
  * Utility class for parsing and constructing database field definitions (IDbForge).
  * Provides methods to analyze field rules and extract type information for schema generation.
  */
-export declare class MachineForge {
+export type IDbForge = {
+    collection: TplCollectionName;
+    fieldName: string;
+    fieldType: TplFieldType;
+    fieldRule: TplFieldRules;
+    fieldArgs: TplFieldArgs;
+    is: "array" | "object" | "fk" | "primitive";
+};
+export declare class MachineParserForge {
+    #private;
     /**
-     * Create a new MachineForge instance.
+     * Create a new MachineParserForge instance.
      */
     constructor();
     /**
@@ -33,21 +23,21 @@ export declare class MachineForge {
      * @param fieldRule - The field rule string to analyze.
      * @returns Partial IDbForge object if the rule matches, otherwise undefined.
      */
-    testIs(what: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge> | undefined;
+    testIs(what: "array" | "object" | "fk" | "primitive", fieldRule: TplFieldRules): Partial<IDbForge> | undefined;
     /**
      * Returns a partial IDbForge object for the given type and field rule.
      * @param what - The type to extract ("array", "object", "fk", "primitive").
      * @param fieldRule - The field rule string to analyze.
      * @returns Partial IDbForge object with extracted type info.
      */
-    is(what: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge>;
+    is(what: "array" | "object" | "fk" | "primitive", fieldRule: TplFieldRules): Partial<IDbForge>;
     /**
      * Extracts type, rule, and argument information from a field rule string.
      * @param type - The type to extract ("array", "object", "fk", "primitive").
      * @param fieldRule - The field rule string to analyze.
      * @returns Partial IDbForge object with extracted details.
      */
-    extract(type: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge>;
+    extract(type: "array" | "object" | "fk" | "primitive", fieldRule: TplFieldRules): Partial<IDbForge>;
     /**
      * Constructs an IDbForge object from its components.
      * @param params - The components of the IDbForge object.

package/dist/main/{machineForge.js → machineParserForge.js}

@@ -1,12 +1,13 @@
-/**
- * Utility class for parsing and constructing database field definitions (IDbForge).
- * Provides methods to analyze field rules and extract type information for schema generation.
- */
-export class MachineForge {
+import { MachineError } from "./machine/MachineError.js";
+export class MachineParserForge {
+    #machineForge;
     /**
-     * Create a new MachineForge instance.
+     * Create a new MachineParserForge instance.
      */
-    constructor() { }
+    constructor() {
+        // Correction : ne pas initialiser #machineForge récursivement
+        this.#machineForge = undefined;
+    }
     /**
      * Test if a field rule matches a specific type (array, object, fk, primitive).
      * @param what - The type to test for ("array", "object", "fk", "primitive").
@@ -70,9 +71,14 @@ export class MachineForge {
         function extractArgs(source) {
             const [piece, remaining] = source.split("(");
             if (!remaining)
-                return { piece: piece.trim(), args: undefined };
-            const [central] = remaining?.split(")");
-            const args = central?.split(" ");
+                return { piece: piece.trim(), args: [] };
+            let central;
+            if (remaining !== undefined) {
+                [central] = remaining.split(")");
+            }
+            const args = central
+                ? central.split(" ")
+                : undefined;
             return { piece: piece.trim(), args };
         }
         const extractedArgs = extractArgs(fieldRule);

package/dist/ui/CollectionButton.svelte

@@ -1,26 +1,29 @@
-<!-- 
-    Component button to open a CreateUpdateShow window for a specific collection.    
-    D:\boulot\python\wollama\src\components\form\CollectionButton.svelte
- -->
-<script lang="ts" generics="COL">
-	import { Button, openWindow } from '@medyll/idae-slotui-svelte';
-	import CreateUpdate from '../form/CreateUpdate.svelte';
-	import { type CreateUpdateProps } from '../form/types.js';
-
-	type CollectionButtonProps = {
-		collection: string;
-		withData?:  Record<string, any>;
-	} & CreateUpdateProps;
-
-	let { collection = 'book', withData, ...rest }: CollectionButtonProps = $props();
-
-	function openCrud(collection: string) {
-		openWindow(`create-${collection}`, {
-			component:       CreateUpdate,
-			componentProps:  { collection: collection, withData, ...rest },
-			hideCloseButton: false
-		});
-	}
-</script>
-
-<Button class="ellipsis" onclick={() => openCrud(collection)} width="auto" icon="mdi:add" value="ui.{rest.mode}-{collection}" />
+<!--
+CollectionButton.svelte
+Svelte 5 button to open CreateUpdate window for a collection
+@role ui-button
+@prop {string} collection - Collection name
+@prop {object} [withData] - Data to prefill
+@slot button - Custom button content
+@event click - Emitted on button click
+-->
+
+<script lang="ts" generics="COL">
+	import { Button, openWindow } from '@medyll/idae-slotui-svelte';
+	import CreateUpdate from '../form/CreateUpdate.svelte';
+	import { type CreateUpdateProps } from '../form/types.js';
+	let { collection = 'book', withData, ...rest } = $props<{ collection?: string; withData?: Record<string, any> } & CreateUpdateProps>();
+	function openCrud(collection: string) {
+		openWindow(`create-${collection}`, {
+			component:       CreateUpdate,
+			componentProps:  { collection, withData, ...rest },
+			hideCloseButton: false
+		});
+	}
+</script>
+
+{#snippet button()}
+	<Button class="ellipsis" onclick={() => openCrud(collection)} width="auto" icon="mdi:add" value={`ui.${rest.mode}-${collection}`} />
+{/snippet}
+
+{@render button()}

package/dist/ui/CollectionButton.svelte.d.ts

@@ -1,10 +1,10 @@
 import { type CreateUpdateProps } from '../form/types.js';
-type CollectionButtonProps = {
-    collection: string;
+type $$ComponentProps = {
+    collection?: string;
     withData?: Record<string, any>;
 } & CreateUpdateProps;
 declare function $$render<COL>(): {
-    props: CollectionButtonProps;
+    props: $$ComponentProps;
     exports: {};
     bindings: "";
     slots: {};

package/dist/ui/CollectionFks.svelte

@@ -1,24 +1,24 @@
-<script lang="ts">
-	import { MachineDb } from '../main/machineDb.js';
-
-	import type { TplCollectionName, Where } from '@medyll/idae-idbql';
-	import { Looper } from '@medyll/idae-slotui-svelte';
-
-	import { machine } from '../main/machine.js'; 
-	type CollectionFksProps = {
-		collection:    TplCollectionName;
-		collectionId?: any;
-		where?:        Where;
-	};
-
-	let { collection,collectionId,where }: CollectionFksProps = $props();
-
- 
-	const fks = $derived(machine.collections.fks(collection)); 
-</script>
-
-<Looper data={Object.entries(fks)}>
-	{#snippet children({ item })}
-		<div>{item[0]}</div>
-	{/snippet}
-</Looper>
+<!--
+CollectionFks.svelte
+Svelte 5 FK relation viewer for a collection
+@role ui-fragment
+@prop {string} collection - Collection name
+@prop {any} [collectionId] - Optional collection id
+@prop {object} [where] - Optional filter
+@slot children (let:item) - Custom FK rendering
+-->
+
+
+<script lang="ts">
+	import type { TplCollectionName, Where } from '@medyll/idae-idbql';
+	import { Looper } from '@medyll/idae-slotui-svelte';
+	import { machine } from '../main/machine.js';
+	let { collection, collectionId, where } = $props<{ collection: TplCollectionName; collectionId?: any; where?: Where }>();
+	const fks = $derived(machine.logic.collection(collection).parseFks());
+</script>
+
+<Looper data={Object.entries(fks)}>
+	{#snippet children(item)}
+		<div>{item[0]}</div>
+	{/snippet}
+</Looper>

package/dist/ui/CollectionFks.svelte.d.ts

@@ -1,9 +1,9 @@
 import type { TplCollectionName, Where } from '@medyll/idae-idbql';
-type CollectionFksProps = {
+type $$ComponentProps = {
     collection: TplCollectionName;
     collectionId?: any;
     where?: Where;
 };
-declare const CollectionFks: import("svelte").Component<CollectionFksProps, {}, "">;
+declare const CollectionFks: import("svelte").Component<$$ComponentProps, {}, "">;
 type CollectionFks = ReturnType<typeof CollectionFks>;
 export default CollectionFks;