@dialecte/core 0.0.16 → 0.0.17

package/dist/{chain-methods → src/chain-methods}/chain-assembler.d.ts

@@ -1,6 +1,6 @@
-import { Chain } from './types';
-import { DatabaseInstance } from '../database';
-import { Context, AnyDialecteConfig, ElementsOf, ExtensionRegistry } from '../types';
+import type { Chain } from './types';
+import type { DatabaseInstance } from '../database';
+import type { Context, AnyDialecteConfig, ElementsOf, ExtensionRegistry } from '../types';
 export declare function chain<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericExtensionRegistry extends ExtensionRegistry<GenericConfig>>(params: {
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
@@ -8,4 +8,3 @@ export declare function chain<GenericConfig extends AnyDialecteConfig, GenericEl
     extensions: GenericExtensionRegistry;
     focusedTagName: GenericElement;
 }): Chain<GenericConfig, GenericElement, GenericExtensionRegistry>;
-//# sourceMappingURL=chain-assembler.d.ts.map

package/dist/{chain-methods → src/chain-methods}/chain-creator.d.ts

@@ -1,6 +1,6 @@
-import { CoreChain, ChainFactory, ExtensionChain } from './types';
-import { DatabaseInstance } from '../database';
-import { Context, AnyDialecteConfig, ElementsOf, ExtensionRegistry } from '../types';
+import type { CoreChain, ChainFactory, ExtensionChain } from './types';
+import type { DatabaseInstance } from '../database';
+import type { Context, AnyDialecteConfig, ElementsOf, ExtensionRegistry } from '../types';
 export declare function createCoreChain<GenericConfig extends AnyDialecteConfig, GenericFocusedElement extends ElementsOf<GenericConfig>, GenericExtensionRegistry extends ExtensionRegistry<GenericConfig> = ExtensionRegistry<GenericConfig>>(params: {
     chain: ChainFactory<GenericConfig, GenericExtensionRegistry>;
     contextPromise: Promise<Context<GenericConfig, GenericFocusedElement>>;
@@ -15,4 +15,3 @@ export declare function createExtensionChain<GenericConfig extends AnyDialecteCo
     dialecteConfig: GenericConfig;
     contextPromise: Promise<Context<GenericConfig, GenericFocusedElement>>;
 }): ExtensionChain<GenericConfig, GenericFocusedElement, GenericExtensionRegistry>;
-//# sourceMappingURL=chain-creator.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/index.d.ts

@@ -1,3 +1,2 @@
 export * from './queries';
 export * from './transaction';
-//# sourceMappingURL=index.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/context.d.ts

@@ -1,5 +1,5 @@
-import { AnyDialecteConfig, ElementsOf } from '../../../types';
-import { Context } from '../../../types/context';
+import type { AnyDialecteConfig, ElementsOf } from '../../../types';
+import type { Context } from '../../../types/context';
 /**
  * Get the internal chain context
  *
@@ -9,4 +9,3 @@ import { Context } from '../../../types/context';
 export declare function createGetContextMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
 }): () => Promise<Context<GenericConfig, GenericElement>>;
-//# sourceMappingURL=context.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/filter-utils.helper.d.ts

@@ -1,5 +1,5 @@
-import { DescendantsFilter, FilterCondition } from './types';
-import { AnyDialecteConfig, ElementsOf } from '../../../../types';
+import type { DescendantsFilter, FilterCondition } from './types';
+import type { AnyDialecteConfig, ElementsOf } from '../../../../types';
 /**
  * Flatten nested filter to flat array of conditions
  * Each condition represents a level in the descendant chain
@@ -10,4 +10,3 @@ export declare function flattenFilterToConditions<GenericConfig extends AnyDiale
  * Extract all tag names from nested filter
  */
 export declare function extractTags<GenericConfig extends AnyDialecteConfig>(filter: DescendantsFilter<GenericConfig>): ElementsOf<GenericConfig>[];
-//# sourceMappingURL=filter-utils.helper.d.ts.map

package/dist/src/chain-methods/ending/queries/descendants/find-descendants-as-tree.d.ts

@@ -0,0 +1,51 @@
+import { DatabaseInstance } from '../../../../database';
+import type { AnyDialecteConfig, Context, ElementsOf, TreeRecord } from '../../../../types';
+export declare function createFindDescendantsAsTreeMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    contextPromise: Promise<Context<GenericConfig, GenericElement>>;
+    dialecteConfig: GenericConfig;
+    databaseInstance: DatabaseInstance<GenericConfig>;
+}): <GenericFilter extends {
+    tagName: ElementsOf<GenericConfig_1>;
+    attributes?: FilterAttributes<GenericConfig_1, K>;
+    descendant?: {
+        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+        descendant?: {
+            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+            descendant?: {
+                tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                descendant?: {
+                    tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                    attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                    descendant?: {
+                        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                        descendant?: {
+                            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                            descendant?: {
+                                tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                descendant?: {
+                                    tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                    attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                    descendant?: {
+                                        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                        descendant?: {
+                                            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                            descendant?: never;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}>(filter: GenericFilter) => Promise<TreeRecord<GenericConfig, GenericFilter["tagName"]>[]>;

package/dist/src/chain-methods/ending/queries/descendants/find-descendants.d.ts

@@ -0,0 +1,59 @@
+import { DatabaseInstance } from '../../../../database';
+import type { FindDescendantsReturn } from './types';
+import type { AnyDialecteConfig, Context, ElementsOf } from '../../../../types';
+/**
+ * Find descendants matching filter with "any depth" semantic
+ *
+ * Two modes:
+ * 1. No filter → get all descendants from tree
+ * 2. With filter → query deepest level, validate ancestors at any depth
+ */
+export declare function createFindDescendantsMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    contextPromise: Promise<Context<GenericConfig, GenericElement>>;
+    dialecteConfig: GenericConfig;
+    databaseInstance: DatabaseInstance<GenericConfig>;
+}): <GenericFilter extends {
+    tagName: ElementsOf<GenericConfig_1>;
+    attributes?: FilterAttributes<GenericConfig_1, K>;
+    descendant?: {
+        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+        descendant?: {
+            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+            descendant?: {
+                tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                descendant?: {
+                    tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                    attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                    descendant?: {
+                        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                        descendant?: {
+                            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                            descendant?: {
+                                tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                descendant?: {
+                                    tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                    attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                    descendant?: {
+                                        tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                        attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                        descendant?: {
+                                            tagName: DescendantsOf<GenericConfig_2, GenericElement_1>;
+                                            attributes?: FilterAttributes<GenericConfig_2, K_1>;
+                                            descendant?: never;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}>(filter?: GenericFilter) => FindDescendantsReturn<GenericConfig, GenericFilter, GenericElement>;

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/flatten-tree.helper.d.ts

@@ -1,6 +1,5 @@
-import { AnyDialecteConfig, ChainRecord, ElementsOf, TreeRecord } from '../../../../types';
+import type { AnyDialecteConfig, ChainRecord, ElementsOf, TreeRecord } from '../../../../types';
 /**
  * Flatten tree to flat list of all descendant records (excluding root)
  */
 export declare function flattenTree<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(tree: TreeRecord<GenericConfig, GenericElement>): ChainRecord<GenericConfig, ElementsOf<GenericConfig>>[];
-//# sourceMappingURL=flatten-tree.helper.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/group-records.helper.d.ts

@@ -1,4 +1,4 @@
-import { AnyDialecteConfig, ChainRecord, ElementsOf } from '../../../../types';
+import type { AnyDialecteConfig, ChainRecord, ElementsOf } from '../../../../types';
 /**
  * Group records by tagName and deduplicate by id
  */
@@ -6,4 +6,3 @@ export declare function groupAndDeduplicate<GenericConfig extends AnyDialecteCon
     collected: Map<string, Map<string, ChainRecord<GenericConfig, ElementsOf<GenericConfig>>>>;
     collectTags: Set<string>;
 }): Record<string, ChainRecord<GenericConfig, ElementsOf<GenericConfig>>[]>;
-//# sourceMappingURL=group-records.helper.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/index.d.ts

@@ -1,4 +1,3 @@
 export * from './find-descendants';
 export * from './find-descendants-as-tree';
 export type * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/match-conditions.helper.d.ts

@@ -1,5 +1,5 @@
-import { FilterCondition } from './types';
-import { AnyDialecteConfig, ChainRecord, ElementsOf } from '../../../../types';
+import type { FilterCondition } from './types';
+import type { AnyDialecteConfig, ChainRecord, ElementsOf } from '../../../../types';
 /**
  * Check if all required filter conditions exist in ancestry chain (any depth)
  * Optional conditions (no attributes) are skipped if not found
@@ -8,4 +8,3 @@ export declare function matchesAllConditions<GenericConfig extends AnyDialecteCo
     ancestry: ChainRecord<GenericConfig, ElementsOf<GenericConfig>>[];
     conditions: FilterCondition<GenericConfig, ElementsOf<GenericConfig>>[];
 }): boolean;
-//# sourceMappingURL=match-conditions.helper.d.ts.map

package/dist/src/chain-methods/ending/queries/descendants/types.d.ts

@@ -0,0 +1,34 @@
+import type { FilterAttributes } from '../../../../helpers';
+import type { AnyDialecteConfig, DescendantsOf, ElementsOf, ChainRecord } from '../../../../types';
+declare type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+declare type FilterNode<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, D extends number> = Depth[D] extends never ? never : {
+    [K in DescendantsOf<GenericConfig, GenericElement>]: {
+        tagName: K;
+        attributes?: FilterAttributes<GenericConfig, K>;
+        descendant?: FilterNode<GenericConfig, K, Depth[D]>;
+    };
+}[DescendantsOf<GenericConfig, GenericElement>];
+export declare type DescendantsFilter<GenericConfig extends AnyDialecteConfig> = {
+    [K in ElementsOf<GenericConfig>]: {
+        tagName: K;
+        attributes?: FilterAttributes<GenericConfig, K>;
+        descendant?: FilterNode<GenericConfig, K, 10>;
+    };
+}[ElementsOf<GenericConfig>];
+export declare type FilterCondition<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    tagName: GenericElement;
+    attributes?: FilterAttributes<GenericConfig, GenericElement>;
+    optional?: boolean;
+};
+export declare type ExtractTags<F> = F extends {
+    tagName: infer T;
+} ? T | (F extends {
+    descendant?: infer D;
+} ? ExtractTags<D> : never) : never;
+export declare type ResultMap<GenericConfig extends AnyDialecteConfig, GenericTags extends string> = {
+    [K in GenericTags]: ChainRecord<GenericConfig, K>[];
+};
+export declare type FindDescendantsReturn<GenericConfig extends AnyDialecteConfig, GenericFilter extends DescendantsFilter<GenericConfig> | undefined, GenericElement extends ElementsOf<GenericConfig> = ElementsOf<GenericConfig>> = Promise<GenericFilter extends undefined ? {
+    [K in GenericElement | DescendantsOf<GenericConfig, GenericElement>]: ChainRecord<GenericConfig, K>[];
+} : GenericFilter extends DescendantsFilter<GenericConfig> ? ResultMap<GenericConfig, ExtractTags<GenericFilter>> : never>;
+export {};

package/dist/{chain-methods → src/chain-methods}/ending/queries/descendants/walk-ancestry.helper.d.ts

@@ -1,5 +1,5 @@
 import { DatabaseInstance } from '../../../../database';
-import { AnyDialecteConfig, ChainRecord, ElementsOf, Operation } from '../../../../types';
+import type { AnyDialecteConfig, ChainRecord, ElementsOf, Operation } from '../../../../types';
 /**
  * Walk up from record to focus, collecting all ancestors
  * Stops when reaching focus element (inclusive)
@@ -12,4 +12,3 @@ export declare function walkAncestryToFocus<GenericConfig extends AnyDialecteCon
     databaseInstance: DatabaseInstance<GenericConfig>;
     stagedOperations: Operation<GenericConfig>[];
 }): Promise<ChainRecord<GenericConfig, ElementsOf<GenericConfig>>[]>;
-//# sourceMappingURL=walk-ancestry.helper.d.ts.map

package/dist/src/chain-methods/ending/queries/find-children.d.ts

@@ -0,0 +1,8 @@
+import type { FindChildrenParams } from './find-children.types';
+import type { DatabaseInstance } from '../../../index';
+import type { AnyDialecteConfig, ElementsOf, Context, ChainRecord } from '../../../types';
+export declare function createFindChildrenMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    contextPromise: Promise<Context<GenericConfig, GenericElement>>;
+    dialecteConfig: GenericConfig;
+    databaseInstance: DatabaseInstance<GenericConfig>;
+}): <GenericChild extends ChildrenOf<GenericConfig, GenericElement>>(filters: Partial<{ [K in GenericChild]: FilterAttributes<GenericConfig_1, K_1>; }>) => Promise<Record<GenericChild, ChainRecord<GenericConfig, GenericChild>[]>>;

package/dist/src/chain-methods/ending/queries/find-children.types.d.ts

@@ -0,0 +1,5 @@
+import type { FilterAttributes } from '../../../helpers';
+import type { AnyDialecteConfig, ElementsOf, ChildrenOf } from '../../../types';
+export declare type FindChildrenParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericChild extends ChildrenOf<GenericConfig, GenericElement>> = Partial<{
+    [K in GenericChild]: FilterAttributes<GenericConfig, K>;
+}>;

package/dist/{chain-methods → src/chain-methods}/ending/queries/get-attributes-values.d.ts

@@ -1,5 +1,4 @@
-import { AnyDialecteConfig, ElementsOf, Context, FullAttributeObjectOf } from '../../../types';
+import type { AnyDialecteConfig, ElementsOf, Context } from '../../../types';
 export declare function createGetAttributesValuesMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
 }): <GenericAttribute extends FullAttributeObjectOf<GenericConfig, GenericElement>>() => Promise<Record<GenericAttribute["name"], GenericAttribute["value"]>>;
-//# sourceMappingURL=get-attributes-values.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/get-parent.d.ts

@@ -1,8 +1,7 @@
 import { DatabaseInstance } from '../../../index';
-import { AnyDialecteConfig, ElementsOf, Context, ParentsOf, ChainRecord } from '../../../types';
+import type { AnyDialecteConfig, ElementsOf, Context, ParentsOf, ChainRecord } from '../../../types';
 export declare function createGetParentMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(params: {
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
 }): () => Promise<ChainRecord<GenericConfig, GenericParentElement>>;
-//# sourceMappingURL=get-parent.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/queries/get-tree.d.ts

@@ -1,9 +1,8 @@
-import { GetTreeParams } from './get-tree.types';
-import { DatabaseInstance } from '../../../index';
-import { AnyDialecteConfig, ElementsOf, Context, TreeRecord } from '../../../types';
+import type { GetTreeParams } from './get-tree.types';
+import type { DatabaseInstance } from '../../../index';
+import type { AnyDialecteConfig, ElementsOf, Context, TreeRecord } from '../../../types';
 export declare function createGetTreeMethod<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
 }): (params?: GetTreeParams<GenericConfig, GenericElement>) => Promise<TreeRecord<GenericConfig, GenericElement>>;
-//# sourceMappingURL=get-tree.d.ts.map

package/dist/src/chain-methods/ending/queries/get-tree.types.d.ts

@@ -0,0 +1,17 @@
+import type { FilterAttributes } from '../../../helpers';
+import type { AnyDialecteConfig, ElementsOf, ChildrenOf } from '../../../types';
+export declare type GetTreeParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    include?: IncludeFilter<GenericConfig, GenericElement>;
+    exclude?: ExcludeFilter<GenericConfig>[];
+    unwrap?: ElementsOf<GenericConfig>[];
+};
+export declare type IncludeFilter<GenericConfig extends AnyDialecteConfig, GenericParent extends ElementsOf<GenericConfig>> = ChildrenOf<GenericConfig, GenericParent> extends infer Child ? Child extends ElementsOf<GenericConfig> ? {
+    tagName: Child;
+    attributes?: FilterAttributes<GenericConfig, Child>;
+    children?: IncludeFilter<GenericConfig, Child>[];
+} : never : never;
+export declare type ExcludeFilter<GenericConfig extends AnyDialecteConfig> = {
+    tagName: ElementsOf<GenericConfig>;
+    attributes?: FilterAttributes<GenericConfig, ElementsOf<GenericConfig>>;
+    scope?: 'self' | 'children';
+};

package/dist/{chain-methods → src/chain-methods}/ending/queries/index.d.ts

@@ -6,4 +6,3 @@ export * from './get-tree';
 export * from './get-attributes-values';
 export type * from './find-children.types';
 export type * from './get-tree.types';
-//# sourceMappingURL=index.d.ts.map

package/dist/{chain-methods → src/chain-methods}/ending/transaction/commit.d.ts

@@ -1,5 +1,5 @@
-import { DatabaseInstance } from '../../../database';
-import { AnyDialecteConfig, ElementsOf, Context } from '../../../types';
+import type { DatabaseInstance } from '../../../database';
+import type { AnyDialecteConfig, ElementsOf, Context } from '../../../types';
 /**
  * Commit all staged operations to the database atomically.
  * Terminal operation - returns Promise<void>, operations cleared after success.
@@ -13,4 +13,3 @@ export declare function createCommitMethod<GenericConfig extends AnyDialecteConf
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
 }): () => Promise<void>;
-//# sourceMappingURL=commit.d.ts.map

package/dist/src/chain-methods/ending/transaction/index.d.ts

@@ -0,0 +1 @@
+export * from './commit';

package/dist/src/chain-methods/ending/transaction/merge-operations.d.ts

@@ -0,0 +1,20 @@
+import type { AnyDialecteConfig, Operation } from '../../../types';
+/**
+ * Merge operations by element ID to optimize database operations.
+ * Consolidates multiple operations on the same element into a single final operation.
+ *
+ * Merge rules:
+ * - created + updated → created (with final state)
+ * - created + deleted → no-op (removed)
+ * - updated + updated → updated (with final state)
+ * - updated + deleted → deleted (with original old state)
+ * - deleted → terminal (no further merging)
+ *
+ * @param operations - Array of staged operations to merge
+ * @returns Object containing arrays of merged creates, updates, and deletes
+ */
+export declare function mergeOperations<GenericConfig extends AnyDialecteConfig>(operations: Operation<GenericConfig>[]): {
+    creates: Operation<GenericConfig>[];
+    updates: Operation<GenericConfig>[];
+    deletes: Operation<GenericConfig>[];
+};

package/dist/{chain-methods → src/chain-methods}/index.d.ts

@@ -3,4 +3,3 @@ export type * from './types';
 export type * from './ending';
 export type * from './mutations';
 export type * from './navigation';
-//# sourceMappingURL=index.d.ts.map

package/dist/{chain-methods → src/chain-methods}/mutations/clone.d.ts

@@ -1,6 +1,6 @@
 import { DeepCloneChildParams } from './clone.types';
-import { Chain, ChainFactory } from '../types';
-import { AnyDialecteConfig, ElementsOf, ChildrenOf, Context, ExtensionRegistry } from '../../types';
+import type { Chain, ChainFactory } from '../types';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Deep clones the child element under the current focused element.
  *
@@ -15,4 +15,3 @@ export declare function createDeepCloneChildMethod<GenericConfig extends AnyDial
     dialecteConfig: GenericConfig;
     focusedTagName: GenericElement;
 }): <GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>>(params: DeepCloneChildParams<GenericConfig, GenericChildElement>) => Chain<GenericConfig, GenericElement, GenericExtensionRegistry> | Chain<GenericConfig, GenericChildElement, GenericExtensionRegistry>;
-//# sourceMappingURL=clone.d.ts.map

package/dist/src/chain-methods/mutations/clone.types.d.ts

@@ -0,0 +1,16 @@
+import type { AnyDialecteConfig, ElementsOf, TreeRecord } from '../../types';
+/**
+ * DeepCloneChild with setFocus: true - narrows to child element type
+ */
+export declare type DeepCloneChildWithFocusParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    record: TreeRecord<GenericConfig, GenericElement>;
+    setFocus: true;
+};
+/**
+ * DeepCloneChild with setFocus: false - stays on current element
+ */
+export declare type DeepCloneChildWithoutFocusParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    record: TreeRecord<GenericConfig, GenericElement>;
+    setFocus: false;
+};
+export declare type DeepCloneChildParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = DeepCloneChildWithFocusParams<GenericConfig, GenericElement> | DeepCloneChildWithoutFocusParams<GenericConfig, GenericElement>;

package/dist/{chain-methods → src/chain-methods}/mutations/create.d.ts

@@ -1,6 +1,6 @@
 import { AddChildParams } from './create.types';
-import { ChainFactory } from '../types';
-import { AnyDialecteConfig, ElementsOf, ChildrenOf, Context, ExtensionRegistry } from '../../types';
+import type { ChainFactory } from '../types';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Creates a child element under the current focused element.
  *
@@ -14,5 +14,4 @@ export declare function createAddChildMethod<GenericConfig extends AnyDialecteCo
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     focusedTagName: GenericElement;
-}): <GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>>(params: AddChildParams<GenericConfig, GenericElement, GenericChildElement>) => import('../types').Chain<GenericConfig, GenericChildElement, GenericExtensionRegistry> | import('../types').Chain<GenericConfig, GenericElement, GenericExtensionRegistry>;
-//# sourceMappingURL=create.d.ts.map
+}): <GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>>(params: AddChildParams<GenericConfig, GenericElement, GenericChildElement>) => any;

package/dist/src/chain-methods/mutations/create.types.d.ts

@@ -0,0 +1,31 @@
+import type { AnyDialecteConfig, ElementsOf, ChildrenOf, Namespace, AttributesValueObjectOf, FullAttributeObjectOf } from '../../types';
+/**
+ * AddChild with setFocus: true - narrows to child element type
+ */
+export declare type AddChildParamsWithFocus<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>> = {
+    id?: `${string}-${string}-${string}-${string}-${string}`;
+    tagName: GenericChildElement;
+    namespace?: Namespace;
+    attributes: AttributesValueObjectOf<GenericConfig, GenericChildElement> | FullAttributeObjectOf<GenericConfig, GenericChildElement>[];
+    value?: string;
+    setFocus: true;
+};
+/**
+ * AddChild with setFocus: false - stays on current element
+ */
+export declare type AddChildParamsWithoutFocus<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>> = {
+    id?: `${string}-${string}-${string}-${string}-${string}`;
+    tagName: GenericChildElement;
+    namespace?: Namespace;
+    attributes: AttributesValueObjectOf<GenericConfig, GenericChildElement> | FullAttributeObjectOf<GenericConfig, GenericChildElement>[];
+    value?: string;
+    setFocus?: false;
+};
+/**
+ * Union type for both addChild variants
+ */
+export declare type AddChildParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>> = AddChildParamsWithFocus<GenericConfig, GenericElement, GenericChildElement> | AddChildParamsWithoutFocus<GenericConfig, GenericElement, GenericChildElement>;
+/**
+ * Any addChild params - for tests or generic operations
+ */
+export declare type AnyAddChildParams = AddChildParams<AnyDialecteConfig, string, string>;

package/dist/{chain-methods → src/chain-methods}/mutations/delete.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseInstance } from '../../index';
-import { ChainFactory } from '../types';
-import { DeleteElementParams } from './delete.types';
-import { AnyDialecteConfig, ElementsOf, Context, ParentsOf, ExtensionRegistry } from '../../types';
+import type { ChainFactory } from '../types';
+import type { DeleteElementParams } from './delete.types';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Deletes the current focused element.
  * Returns builder focused on parent element.
@@ -16,5 +16,4 @@ export declare function createDeleteElementMethod<GenericConfig extends AnyDiale
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
-}): <GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(params: DeleteElementParams<GenericConfig, GenericElement, GenericParentElement>) => import('../../index').Chain<GenericConfig, GenericParentElement, GenericExtensionRegistry>;
-//# sourceMappingURL=delete.d.ts.map
+}): <GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(params: DeleteElementParams<GenericConfig, GenericElement, GenericParentElement>) => import("../types").Chain<GenericConfig, GenericParentElement, GenericExtensionRegistry>;

package/dist/src/chain-methods/mutations/delete.types.d.ts

@@ -0,0 +1,5 @@
+import type { AnyDialecteConfig, ElementsOf, AnyElement, ParentsOf, AnyParent } from '../../types';
+export declare type DeleteElementParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericParentElement extends ParentsOf<GenericConfig, GenericElement>> = {
+    parentTagName: GenericParentElement;
+};
+export declare type AnyDeleteParams = DeleteElementParams<AnyDialecteConfig, AnyElement, AnyParent>;

package/dist/{chain-methods → src/chain-methods}/mutations/index.d.ts

@@ -6,4 +6,3 @@ export type * from './create.types';
 export type * from './clone.types';
 export type * from './update.types';
 export type * from './delete.types';
-//# sourceMappingURL=index.d.ts.map

package/dist/{chain-methods → src/chain-methods}/mutations/update.d.ts

@@ -1,6 +1,6 @@
 import { UpdateElementParams } from './update.types';
-import { ChainFactory } from '../types';
-import { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
+import type { ChainFactory } from '../types';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Updates the current focused element's attributes or value.
  *
@@ -13,5 +13,4 @@ export declare function createUpdateElementMethod<GenericConfig extends AnyDiale
     chain: ChainFactory<GenericConfig, GenericExtensionRegistry>;
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
-}): (params: UpdateElementParams<GenericConfig, GenericElement>) => import('../types').Chain<GenericConfig, GenericElement, GenericExtensionRegistry>;
-//# sourceMappingURL=update.d.ts.map
+}): (params: UpdateElementParams<GenericConfig, GenericElement>) => import("../types").Chain<GenericConfig, GenericElement, GenericExtensionRegistry>;

package/dist/src/chain-methods/mutations/update.types.d.ts

@@ -0,0 +1,5 @@
+import type { AnyDialecteConfig, ElementsOf, AttributesValueObjectOf } from '../../types';
+export declare type UpdateElementParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    attributes?: Partial<AttributesValueObjectOf<GenericConfig, GenericElement>>;
+    value?: string;
+};

package/dist/{chain-methods → src/chain-methods}/navigation/go-to-element.d.ts

@@ -1,7 +1,7 @@
 import { GoToElementParams } from './types';
-import { ChainFactory } from '../types';
-import { DatabaseInstance } from '../../database';
-import { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
+import type { ChainFactory } from '../types';
+import type { DatabaseInstance } from '../../database';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Navigate to a specific element by tagName and id.
  * Type narrows to the target element.
@@ -15,5 +15,4 @@ export declare function createGoToElementMethod<GenericConfig extends AnyDialect
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
-}): <GenericFocusElement extends ElementsOf<GenericConfig>>(params: GoToElementParams<GenericConfig, GenericFocusElement>) => import('../types').Chain<GenericConfig, GenericFocusElement, GenericExtensionRegistry>;
-//# sourceMappingURL=go-to-element.d.ts.map
+}): <GenericFocusElement extends ElementsOf<GenericConfig>>(params: GoToElementParams<GenericConfig, GenericFocusElement>) => import("../types").Chain<GenericConfig, GenericFocusElement, GenericExtensionRegistry>;

package/dist/{chain-methods → src/chain-methods}/navigation/go-to-parent.d.ts

@@ -1,7 +1,7 @@
-import { ChainFactory } from '../types';
-import { GoToParentParams } from './types';
-import { DatabaseInstance } from '../../database';
-import { AnyDialecteConfig, ElementsOf, Context, ParentsOf, ExtensionRegistry } from '../../types';
+import type { ChainFactory } from '../types';
+import type { GoToParentParams } from './types';
+import type { DatabaseInstance } from '../../database';
+import type { AnyDialecteConfig, ElementsOf, Context, ExtensionRegistry } from '../../types';
 /**
  * Navigate to the parent element.
  * Type narrows to the target element.
@@ -15,5 +15,4 @@ export declare function createGoToParentMethod<GenericConfig extends AnyDialecte
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
     dialecteConfig: GenericConfig;
     databaseInstance: DatabaseInstance<GenericConfig>;
-}): <GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(parentTagName: GoToParentParams<GenericConfig, GenericElement, GenericParentElement>) => import('../types').Chain<GenericConfig, GenericParentElement, GenericExtensionRegistry>;
-//# sourceMappingURL=go-to-parent.d.ts.map
+}): <GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(parentTagName: GenericParentElement) => import("../types").Chain<GenericConfig, GenericParentElement, GenericExtensionRegistry>;

package/dist/{chain-methods → src/chain-methods}/navigation/index.d.ts

@@ -1,4 +1,3 @@
 export * from './go-to-element';
 export * from './go-to-parent';
 export type * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/chain-methods/navigation/types.d.ts

@@ -0,0 +1,11 @@
+import type { AnyDialecteConfig, ElementsOf, SingletonElementsOf, AnyElement, ParentsOf, AnyParent } from '../../types';
+export declare type GoToElementParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericElement extends SingletonElementsOf<GenericConfig> ? {
+    tagName: GenericElement;
+    id?: string;
+} : {
+    tagName: GenericElement;
+    id: string;
+};
+export declare type AnyGoToElementParams = GoToElementParams<AnyDialecteConfig, AnyElement>;
+export declare type GoToParentParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericParentElement extends ParentsOf<GenericConfig, GenericElement>> = GenericParentElement;
+export declare type AnyGoToParentParams = GoToParentParams<AnyDialecteConfig, AnyElement, AnyParent>;