@dialecte/core 0.0.16 → 0.0.17

package/dist/{helpers → src/helpers}/test-fixtures/generated/types.generated.d.ts

@@ -1,160 +1,160 @@
-import { ELEMENT_NAMES, REQUIRED_ATTRIBUTES } from './constants.generated';
-export type AvailableElement = (typeof ELEMENT_NAMES)[number];
-export type AttributesA = {
+import type { ELEMENT_NAMES, REQUIRED_ATTRIBUTES } from './constants.generated';
+export declare type AvailableElement = (typeof ELEMENT_NAMES)[number];
+export declare type AttributesA = {
     aA: string;
     bA?: string;
     cA?: string;
 };
-export type AttributesAAAA_1 = {
+export declare type AttributesAAAA_1 = {
     aAAAA_1: string;
     bAAAA_1?: string;
     cAAAA_1?: string;
 };
-export type AttributesAAAA_2 = {
+export declare type AttributesAAAA_2 = {
     aAAAA_2: string;
     bAAAA_2?: string;
     cAAAA_2?: string;
 };
-export type AttributesAAAA_3 = {
+export declare type AttributesAAAA_3 = {
     aAAAA_3: string;
     bAAAA_3?: string;
     cAAAA_3?: string;
 };
-export type AttributesAAA_1 = {
+export declare type AttributesAAA_1 = {
     aAAA_1: string;
     bAAA_1?: string;
     cAAA_1?: string;
 };
-export type AttributesAAA_2 = {
+export declare type AttributesAAA_2 = {
     aAAA_2: string;
     bAAA_2?: string;
     cAAA_2?: string;
 };
-export type AttributesAAA_3 = {
+export declare type AttributesAAA_3 = {
     aAAA_3: string;
     bAAA_3?: string;
     cAAA_3?: string;
 };
-export type AttributesAA_1 = {
+export declare type AttributesAA_1 = {
     aAA_1: string;
     bAA_1?: string;
     cAA_1?: string;
 };
-export type AttributesAA_2 = {
+export declare type AttributesAA_2 = {
     aAA_2: string;
     bAA_2?: string;
     cAA_2?: string;
 };
-export type AttributesAA_3 = {
+export declare type AttributesAA_3 = {
     aAA_3: string;
     bAA_3?: string;
     cAA_3?: string;
 };
-export type AttributesB = {
+export declare type AttributesB = {
     aB: string;
     bB?: string;
     cB?: string;
 };
-export type AttributesBBBB_1 = {
+export declare type AttributesBBBB_1 = {
     aBBBB_1: string;
     bBBBB_1?: string;
     cBBBB_1?: string;
 };
-export type AttributesBBBB_2 = {
+export declare type AttributesBBBB_2 = {
     aBBBB_2: string;
     bBBBB_2?: string;
     cBBBB_2?: string;
 };
-export type AttributesBBBB_3 = {
+export declare type AttributesBBBB_3 = {
     aBBBB_3: string;
     bBBBB_3?: string;
     cBBBB_3?: string;
 };
-export type AttributesBBB_1 = {
+export declare type AttributesBBB_1 = {
     aBBB_1: string;
     bBBB_1?: string;
     cBBB_1?: string;
 };
-export type AttributesBBB_2 = {
+export declare type AttributesBBB_2 = {
     aBBB_2: string;
     bBBB_2?: string;
     cBBB_2?: string;
 };
-export type AttributesBBB_3 = {
+export declare type AttributesBBB_3 = {
     aBBB_3: string;
     bBBB_3?: string;
     cBBB_3?: string;
 };
-export type AttributesBB_1 = {
+export declare type AttributesBB_1 = {
     aBB_1: string;
     bBB_1?: string;
     cBB_1?: string;
 };
-export type AttributesBB_2 = {
+export declare type AttributesBB_2 = {
     aBB_2: string;
     bBB_2?: string;
     cBB_2?: string;
 };
-export type AttributesBB_3 = {
+export declare type AttributesBB_3 = {
     aBB_3: string;
     bBB_3?: string;
     cBB_3?: string;
 };
-export type AttributesC = {
+export declare type AttributesC = {
     aC: string;
     bC?: string;
     cC?: string;
 };
-export type AttributesCCCC_1 = {
+export declare type AttributesCCCC_1 = {
     aCCCC_1: string;
     bCCCC_1?: string;
     cCCCC_1?: string;
 };
-export type AttributesCCCC_2 = {
+export declare type AttributesCCCC_2 = {
     aCCCC_2: string;
     bCCCC_2?: string;
     cCCCC_2?: string;
 };
-export type AttributesCCCC_3 = {
+export declare type AttributesCCCC_3 = {
     aCCCC_3: string;
     bCCCC_3?: string;
     cCCCC_3?: string;
 };
-export type AttributesCCC_1 = {
+export declare type AttributesCCC_1 = {
     aCCC_1: string;
     bCCC_1?: string;
     cCCC_1?: string;
 };
-export type AttributesCCC_2 = {
+export declare type AttributesCCC_2 = {
     aCCC_2: string;
     bCCC_2?: string;
     cCCC_2?: string;
 };
-export type AttributesCCC_3 = {
+export declare type AttributesCCC_3 = {
     aCCC_3: string;
     bCCC_3?: string;
     cCCC_3?: string;
 };
-export type AttributesCC_1 = {
+export declare type AttributesCC_1 = {
     aCC_1: string;
     bCC_1?: string;
     cCC_1?: string;
 };
-export type AttributesCC_2 = {
+export declare type AttributesCC_2 = {
     aCC_2: string;
     bCC_2?: string;
     cCC_2?: string;
 };
-export type AttributesCC_3 = {
+export declare type AttributesCC_3 = {
     aCC_3: string;
     bCC_3?: string;
     cCC_3?: string;
 };
-export type AttributesRoot = {
+export declare type AttributesRoot = {
     root: string;
     'ext:root'?: string;
 };
-type AttributesMap = {
+declare type AttributesMap = {
     A: AttributesA;
     AAAA_1: AttributesAAAA_1;
     AAAA_2: AttributesAAAA_2;
@@ -187,8 +187,7 @@ type AttributesMap = {
     CC_3: AttributesCC_3;
     Root: AttributesRoot;
 };
-export type AttributesOf<T extends AvailableElement> = AttributesMap[T];
-export type RequiredAttributeNames<T extends AvailableElement> = (typeof REQUIRED_ATTRIBUTES)[T][number];
-export type OptionalAttributeNames<T extends AvailableElement> = Exclude<keyof AttributesOf<T>, RequiredAttributeNames<T>>;
+export declare type AttributesOf<T extends AvailableElement> = AttributesMap[T];
+export declare type RequiredAttributeNames<T extends AvailableElement> = (typeof REQUIRED_ATTRIBUTES)[T][number];
+export declare type OptionalAttributeNames<T extends AvailableElement> = Exclude<keyof AttributesOf<T>, RequiredAttributeNames<T>>;
 export {};
-//# sourceMappingURL=types.generated.d.ts.map

package/dist/{helpers → src/helpers}/test-fixtures/index.d.ts

@@ -4,4 +4,3 @@ export * from './test-record';
 export * from './create-test-dialecte';
 export * from './test-operations';
 export type * from './test-operations.types';
-//# sourceMappingURL=index.d.ts.map

package/dist/{helpers → src/helpers}/test-fixtures/test-operations.d.ts

@@ -1,6 +1,6 @@
-import { ChainTestOperation } from './test-operations.types';
-import { Chain } from '../../chain-methods';
-import { AnyDialecteConfig, ElementsOf, ChildrenOf, ExtensionRegistry } from '../../types';
+import type { ChainTestOperation } from './test-operations.types';
+import type { Chain } from '../../chain-methods';
+import type { AnyDialecteConfig, ElementsOf, ChildrenOf, ExtensionRegistry } from '../../types';
 /**
  * Execute a series of operations on a chain
  * Returns committed context
@@ -11,5 +11,4 @@ import { AnyDialecteConfig, ElementsOf, ChildrenOf, ExtensionRegistry } from '..
 export declare function executeTableDrivenTestsChainOperations<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig> = ElementsOf<GenericConfig>, GenericExtensionRegistry extends ExtensionRegistry<GenericConfig> = {}>(params: {
     chain: Chain<GenericConfig, GenericElement, GenericExtensionRegistry>;
     operations: Array<ChainTestOperation<GenericConfig, ElementsOf<GenericConfig>, ChildrenOf<GenericConfig, ElementsOf<GenericConfig>>>>;
-}): Promise<import('../../types').Context<AnyDialecteConfig, string>>;
-//# sourceMappingURL=test-operations.d.ts.map
+}): Promise<any>;

package/dist/src/helpers/test-fixtures/test-operations.types.d.ts

@@ -0,0 +1,19 @@
+import { GoToElementParams } from '../../chain-methods/navigation';
+import type { AddChildParams, UpdateElementParams } from '../../chain-methods/mutations';
+import type { AnyDialecteConfig, ChildrenOf, ElementsOf } from '../../types';
+export declare type ChainTestOperation<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericChildElement extends ChildrenOf<GenericConfig, GenericElement>> = ({
+    type: 'update';
+    goTo?: GoToElementParams<GenericConfig, GenericElement>;
+} & UpdateElementParams<GenericConfig, GenericElement>) | {
+    type: 'delete';
+    goTo?: GoToElementParams<GenericConfig, GenericElement>;
+} | ({
+    type: 'addChild';
+    goTo?: GoToElementParams<GenericConfig, GenericElement>;
+} & AddChildParams<GenericConfig, GenericElement, GenericChildElement>);
+export declare type AnyChainTestOperation = ChainTestOperation<AnyDialecteConfig, ElementsOf<AnyDialecteConfig>, ChildrenOf<AnyDialecteConfig, ElementsOf<AnyDialecteConfig>>>;
+/**
+ * For table-driven tests where operations can target any element in the config.
+ * This creates a distributive union that maintains proper type narrowing for each operation.
+ */
+export declare type AnyElementChainTestOperation<GenericConfig extends AnyDialecteConfig> = ElementsOf<GenericConfig> extends infer Element ? Element extends ElementsOf<GenericConfig> ? ChainTestOperation<GenericConfig, Element, ChildrenOf<GenericConfig, Element>> : never : never;

package/dist/{helpers → src/helpers}/test-fixtures/test-record.d.ts

@@ -1,6 +1,6 @@
 import { TEST_DIALECTE_CONFIG } from './config';
-import { ElementsOf, FullAttributeObjectOf, RawRecord, ChainRecord, AttributesValueObjectOf, TreeRecord } from '../../types';
-type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
+import type { ElementsOf, FullAttributeObjectOf, RawRecord, ChainRecord, AttributesValueObjectOf, TreeRecord } from '../../types';
+declare type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
 /**
  * Create a test record for TEST_DIALECTE_CONFIG
  * Helper function for test data generation
@@ -33,4 +33,3 @@ export declare function createTestRecord<GenericElement extends ElementsOf<TestD
     } & Partial<RawRecord<TestDialecteConfig, GenericElement>>;
 }): TreeRecord<TestDialecteConfig, GenericElement>;
 export {};
-//# sourceMappingURL=test-record.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './chain-methods';
+export * from './database';
+export * from './io';
+export * from './dialecte';
+export * from './helpers';
+export * from './utils';
+export type * from './types';

package/dist/{io → src/io}/export/constant.d.ts

@@ -1,2 +1 @@
 export declare const TEMP_IDB_ID_ATTRIBUTE_NAME = "_temp-idb-id";
-//# sourceMappingURL=constant.d.ts.map

package/dist/{io → src/io}/export/download-file.d.ts

@@ -1,7 +1,6 @@
-import { AnyDialecteConfig } from '../../types';
+import type { AnyDialecteConfig } from '../../types';
 export declare function downloadFile<GenericConfig extends AnyDialecteConfig>(params: {
     extension: GenericConfig['io']['supportedFileExtensions'][number];
     xmlDocument: XMLDocument;
     filename: string;
 }): Promise<void>;
-//# sourceMappingURL=download-file.d.ts.map

package/dist/{io → src/io}/export/formatter.d.ts

@@ -1,2 +1 @@
 export declare function formatXml(xmlString: string): string;
-//# sourceMappingURL=formatter.d.ts.map

package/dist/{io → src/io}/export/index.d.ts

@@ -1,4 +1,3 @@
 export * from './main';
 export * from './formatter';
 export * from './constant';
-//# sourceMappingURL=index.d.ts.map

package/dist/{io → src/io}/export/main.d.ts

@@ -1,4 +1,4 @@
-import { AnyDialecteConfig } from '../../types';
+import type { AnyDialecteConfig } from '../../types';
 /**
  * Generic XML export function that works with any dialecte
  * @param databaseName - Name of the database to export
@@ -21,4 +21,3 @@ export declare function exportXmlDocumentForOpenSCD(params: {
     xmlDocument: XMLDocument;
     filename: string;
 }>;
-//# sourceMappingURL=main.d.ts.map

package/dist/{io → src/io}/import/database-helpers.d.ts

@@ -1,4 +1,4 @@
-import { default as Dexie } from 'dexie';
+import Dexie from 'dexie';
 import { AnyRawRecord } from '../../types';
 /**
  * Add a batch of records to the elements table
@@ -18,4 +18,3 @@ export declare function bulkAddRecords(params: {
  * @returns Promise that resolves when deletion is complete
  */
 export declare function deleteDatabaseIfExists(databaseName: string): Promise<void>;
-//# sourceMappingURL=database-helpers.d.ts.map

package/dist/{io → src/io}/import/guards.d.ts

@@ -1,4 +1,3 @@
 import type * as sax from 'sax';
 export declare function isSaxQualifiedTag(node: sax.Tag | sax.QualifiedTag): node is sax.QualifiedTag;
 export declare function isSaxQualifiedAttribute(attribute: string | sax.QualifiedAttribute | undefined): attribute is sax.QualifiedAttribute;
-//# sourceMappingURL=guards.d.ts.map

package/dist/{io → src/io}/import/index.d.ts

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

package/dist/{io → src/io}/import/main.d.ts

@@ -1,4 +1,4 @@
-import { AnyDialecteConfig } from '../../types';
+import type { AnyDialecteConfig } from '../../types';
 export declare function importXmlFiles(params: {
     files: File[];
     dialecteConfig: AnyDialecteConfig;
@@ -12,4 +12,3 @@ export declare function isFileSupported(params: {
     supportedExtensions: readonly string[];
 }): boolean;
 export declare function getDatabaseName(file: File): string;
-//# sourceMappingURL=main.d.ts.map

package/dist/{io → src/io}/import/parser.d.ts

@@ -1,5 +1,5 @@
-import { ParserInstance } from './types';
-import { AnyDialecteConfig } from '../../types';
+import type { ParserInstance } from './types';
+import type { AnyDialecteConfig } from '../../types';
 /**
  * Sets up the SAX parser for XML parsing.
  * @param namespaces Namespace configuration from dialecte
@@ -10,4 +10,3 @@ export declare function setSaxParser(params: {
     dialecteConfig: AnyDialecteConfig;
     useCustomRecordsIds: boolean;
 }): ParserInstance;
-//# sourceMappingURL=parser.d.ts.map

package/dist/{io → src/io}/import/relationships.d.ts

@@ -1,4 +1,4 @@
-import { AnyRelationship, AnyRawRecord } from '../../types';
+import type { AnyRelationship, AnyRawRecord } from '../../types';
 export declare function registerPendingChildrenRelationship(params: {
     parentId: string;
     child: AnyRelationship;
@@ -6,4 +6,3 @@ export declare function registerPendingChildrenRelationship(params: {
 export declare function resolveCurrentBatchChildrenRelationships(params: {
     currentBatch: AnyRawRecord[];
 }): AnyRawRecord[];
-//# sourceMappingURL=relationships.d.ts.map

package/dist/{io → src/io}/import/types.d.ts

@@ -1,13 +1,12 @@
-import { AnyRawRecord, Namespace } from '../../types';
-import { SAXParser } from 'sax';
-export type ParserInstance = {
+import type { AnyRawRecord, Namespace } from '../../types';
+import type { SAXParser } from 'sax';
+export declare type ParserInstance = {
     parser: SAXParser;
     drainBatch: () => AnyRawRecord[];
     getSize: () => number;
 };
-export type ParserState = {
+export declare type ParserState = {
     defaultNamespace: Namespace | null;
     stack: AnyRawRecord[];
     recordsBatch: AnyRawRecord[];
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/{io → src/io}/index.d.ts

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

package/dist/src/types/context.d.ts

@@ -0,0 +1,15 @@
+import type { AnyDialecteConfig, ElementsOf } from './dialecte-config';
+import type { Operation } from './operations';
+import type { ChainRecord } from './records';
+/**
+ * Context carries the state through the promise chain
+ * Each operation returns a new builder with updated context
+ */
+export declare type Context<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+    currentFocus: ChainRecord<GenericConfig, GenericElement>;
+    stagedOperations: Operation<GenericConfig>[];
+};
+/**
+ * Generic context for situations where element type is not yet known
+ */
+export declare type AnyContext = Context<AnyDialecteConfig, ElementsOf<AnyDialecteConfig>>;

package/dist/{types → src/types}/definition.d.ts

@@ -1,8 +1,8 @@
-import { Namespace } from './records';
+import type { Namespace } from './records';
 /**
  * Validation rules that can be applied to attributes, elements, or values
  */
-export type ValidationRules = {
+export declare type ValidationRules = {
     readonly enumeration: readonly string[] | null;
     readonly pattern: readonly string[] | null;
     readonly minInclusive: number | string | null;
@@ -19,7 +19,7 @@ export type ValidationRules = {
 /**
  * Attribute definition with validation rules
  */
-export type AttributeDefinition = {
+export declare type AttributeDefinition = {
     readonly required: boolean;
     readonly default: string | null;
     readonly namespace: Namespace | null;
@@ -28,7 +28,7 @@ export type AttributeDefinition = {
 /**
  * Sub-element definition with constraints
  */
-export type SubElementDefinition = {
+export declare type SubElementDefinition = {
     readonly required: boolean;
     readonly validation: ValidationRules;
     readonly constraints: readonly any[] | null;
@@ -37,7 +37,7 @@ export type SubElementDefinition = {
  * Generic element definition parameterized by element type
  * Provides typed access to attributes, sub-elements, and parents
  */
-export type ElementDefinition = {
+export declare type ElementDefinition = {
     readonly tag: string;
     readonly namespace: Namespace;
     readonly documentation: string | null;
@@ -66,5 +66,4 @@ export type ElementDefinition = {
  *
  * Each dialecte should define its own specific type extending this
  */
-export type AnyDefinition = Record<string, ElementDefinition>;
-//# sourceMappingURL=definition.d.ts.map
+export declare type AnyDefinition = Record<string, ElementDefinition>;

package/dist/{types → src/types}/dialecte-config.d.ts

@@ -1,10 +1,10 @@
-import { Context } from './context';
-import { AnyDefinition } from './definition';
-import { ImportOptions, ExportOptions } from './io';
-import { Operation } from './operations';
-import { Namespace, RawRecord, TreeRecord } from './records';
-import { ChainFactory } from '../chain-methods';
-export type RawDialecteConfig<GenericElementNames extends readonly string[], GenericRootElement extends GenericElementNames[number], GenericAttributes extends Record<string, any>, GenericChildren extends Record<string, readonly string[]>, GenericParents extends Record<string, readonly string[]>, GenericDescendants extends Record<string, readonly string[]>, GenericAncestors extends Record<string, readonly string[]>> = {
+import type { Context } from './context';
+import type { AnyDefinition } from './definition';
+import type { ImportOptions, ExportOptions } from './io';
+import type { Operation } from './operations';
+import type { Namespace, RawRecord, TreeRecord } from './records';
+import type { ChainFactory } from '../chain-methods';
+export declare type RawDialecteConfig<GenericElementNames extends readonly string[], GenericRootElement extends GenericElementNames[number], GenericAttributes extends Record<string, any>, GenericChildren extends Record<string, readonly string[]>, GenericParents extends Record<string, readonly string[]>, GenericDescendants extends Record<string, readonly string[]>, GenericAncestors extends Record<string, readonly string[]>> = {
     rootElementName: GenericRootElement;
     singletonElements?: readonly GenericElementNames[number][];
     namespaces: Record<'default', Namespace> & Record<string, Namespace>;
@@ -19,12 +19,12 @@ export type RawDialecteConfig<GenericElementNames extends readonly string[], Gen
     definition: AnyDefinition;
     hooks: DialecteHooks;
 };
-export type IOConfig = {
+export declare type IOConfig = {
     supportedFileExtensions: readonly string[];
     importOptions?: Partial<ImportOptions>;
     exportOptions?: Partial<ExportOptions>;
 };
-export type ExtensionsMethodParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericExtensionRegistry extends ExtensionRegistry<GenericConfig> = ExtensionRegistry<GenericConfig>> = {
+export declare type ExtensionsMethodParams<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericExtensionRegistry extends ExtensionRegistry<GenericConfig> = ExtensionRegistry<GenericConfig>> = {
     chain: ChainFactory<GenericConfig, GenericExtensionRegistry>;
     dialecteConfig: GenericConfig;
     contextPromise: Promise<Context<GenericConfig, GenericElement>>;
@@ -33,15 +33,15 @@ export type ExtensionsMethodParams<GenericConfig extends AnyDialecteConfig, Gene
  * Extension method creator - receives context params and returns the actual extension method
  * The returned method should be chainable (return a CoreChain) unless it's an ending method
  */
-export type ExtensionMethodCreator<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = (params: ExtensionsMethodParams<GenericConfig, GenericElement>) => (...args: any[]) => any;
+export declare type ExtensionMethodCreator<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = (params: ExtensionsMethodParams<GenericConfig, GenericElement>) => (...args: any[]) => any;
 /**
  * Extension registry - maps element types to their extension methods
  * Each element can have multiple extension methods identified by method name
  */
-export type ExtensionRegistry<GenericConfig extends AnyDialecteConfig> = Partial<{
+export declare type ExtensionRegistry<GenericConfig extends AnyDialecteConfig> = Partial<{
     [K in ElementsOf<GenericConfig>]: Record<string, ExtensionMethodCreator<GenericConfig, K>>;
 }>;
-export type DialecteHooks = {
+export declare type DialecteHooks = {
     /**
      * Called before cloning a record.
      * Return modified attributes for the clone.
@@ -69,7 +69,7 @@ export type DialecteHooks = {
         context: Context<GenericConfig, GenericParentElement>;
     }) => Operation<GenericConfig>[];
 };
-export type DatabaseConfig = Readonly<{
+export declare type DatabaseConfig = Readonly<{
     tables: {
         xmlElements: {
             name: string;
@@ -84,26 +84,26 @@ export type DatabaseConfig = Readonly<{
  * Generic FlavorConfig type for contexts where specific flavor is not known.
  * Use this instead of FlavorConfig<any, any, any, any, any>
  */
-export type AnyDialecteConfig = RawDialecteConfig<readonly string[], string, Record<string, any>, Record<string, readonly string[]>, Record<string, readonly string[]>, Record<string, readonly string[]>, Record<string, readonly string[]>>;
+export declare type AnyDialecteConfig = RawDialecteConfig<readonly string[], string, Record<string, any>, Record<string, readonly string[]>, Record<string, readonly string[]>, Record<string, readonly string[]>, Record<string, readonly string[]>>;
 /**
  * Extract the element union type from a dialecte config
  */
-export type ElementsOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['elements'][number];
-export type AnyElement = string;
+export declare type ElementsOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['elements'][number];
+export declare type AnyElement = string;
 /**
  * Get attributes type for a specific element from dialecte config
  */
-export type AttributesValueObjectOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['attributes'][GenericElement];
-export type AnyAttributesValueObject = Record<string, string>;
+export declare type AttributesValueObjectOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['attributes'][GenericElement];
+export declare type AnyAttributesValueObject = Record<string, string>;
 /**
  * Get attribute name union for a specific element from dialecte config
  */
-export type AttributesOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = keyof AttributesValueObjectOf<GenericConfig, GenericElement> & string;
-export type AnyAttributeName = string;
+export declare type AttributesOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = keyof AttributesValueObjectOf<GenericConfig, GenericElement> & string;
+export declare type AnyAttributeName = string;
 /**
  * Get attribute object type for a specific element from dialecte config
  */
-export type FullAttributeObjectOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
+export declare type FullAttributeObjectOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = {
     [K in AttributesOf<GenericConfig, GenericElement>]: {
         name: K;
         value: AttributesValueObjectOf<GenericConfig, GenericElement>[K];
@@ -113,29 +113,28 @@ export type FullAttributeObjectOf<GenericConfig extends AnyDialecteConfig, Gener
 /**
  * Get valid children elements for a specific element from dialecte config
  */
-export type ChildrenOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['children'][GenericElement][number];
-export type AnyChildren = ChildrenOf<AnyDialecteConfig, AnyElement>;
+export declare type ChildrenOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['children'][GenericElement][number];
+export declare type AnyChildren = ChildrenOf<AnyDialecteConfig, AnyElement>;
 /**
  * Get valid parent elements for a specific element from dialecte config
  */
-export type ParentsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['parents'][GenericElement][number];
-export type AnyParent = ParentsOf<AnyDialecteConfig, AnyElement>;
+export declare type ParentsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['parents'][GenericElement][number];
+export declare type AnyParent = ParentsOf<AnyDialecteConfig, AnyElement>;
 /**
  * Get descendants elements for a specific element from dialecte config
  */
-export type DescendantsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['descendants'][GenericElement][number];
-export type AnyDescendant = DescendantsOf<AnyDialecteConfig, AnyElement>;
+export declare type DescendantsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['descendants'][GenericElement][number];
+export declare type AnyDescendant = DescendantsOf<AnyDialecteConfig, AnyElement>;
 /**
  * Get ancestors elements for a specific element from dialecte config
  */
-export type AncestorsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['ancestors'][GenericElement][number];
-export type AnyAncestors = AncestorsOf<AnyDialecteConfig, AnyElement>;
+export declare type AncestorsOf<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>> = GenericConfig['ancestors'][GenericElement][number];
+export declare type AnyAncestors = AncestorsOf<AnyDialecteConfig, AnyElement>;
 /**
  * Get the root element type from a dialecte config
  */
-export type RootElementOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['rootElementName'];
+export declare type RootElementOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['rootElementName'];
 /**
  * Get singleton elements from dialecte config
  */
-export type SingletonElementsOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['singletonElements'] extends readonly (infer E)[] ? E : never;
-//# sourceMappingURL=dialecte-config.d.ts.map
+export declare type SingletonElementsOf<GenericConfig extends AnyDialecteConfig> = GenericConfig['singletonElements'] extends readonly (infer E)[] ? E : never;

package/dist/{types → src/types}/index.d.ts

@@ -4,4 +4,3 @@ export type * from './operations';
 export type * from './context';
 export type * from './io';
 export type * from './definition';
-//# sourceMappingURL=index.d.ts.map

package/dist/{types → src/types}/io.d.ts

@@ -1,17 +1,16 @@
 /**
  * Options for chunking during import/export
  */
-export type ChunkOptions = {
+export declare type ChunkOptions = {
     batchSize: number;
     chunkSize: number;
 };
 /**
  * Options for importing XML files
  */
-export type ImportOptions = ChunkOptions & {
+export declare type ImportOptions = ChunkOptions & {
     useBrowserApi: boolean;
 };
-export type ExportOptions = {
+export declare type ExportOptions = {
     useBrowserApi: boolean;
 };
-//# sourceMappingURL=io.d.ts.map

package/dist/{types → src/types}/operations.d.ts

@@ -1,13 +1,13 @@
-import { AnyDialecteConfig, ElementsOf } from './dialecte-config';
-import { RawRecord } from './records';
+import type { AnyDialecteConfig, ElementsOf } from './dialecte-config';
+import type { RawRecord } from './records';
 /**
  * Operation status for tracking element lifecycle
  */
-export type OperationStatus = 'created' | 'updated' | 'deleted' | 'unchanged';
+export declare type OperationStatus = 'created' | 'updated' | 'deleted' | 'unchanged';
 /**
  * Staged operation - tracks changes before commit
  */
-export type Operation<GenericConfig extends AnyDialecteConfig> = {
+export declare type Operation<GenericConfig extends AnyDialecteConfig> = {
     status: 'created';
     oldRecord: undefined;
     newRecord: RawRecord<GenericConfig, ElementsOf<GenericConfig>>;
@@ -23,5 +23,4 @@ export type Operation<GenericConfig extends AnyDialecteConfig> = {
 /**
  * Generic operation for contexts where specific dialecte is not known
  */
-export type AnyOperation = Operation<AnyDialecteConfig>;
-//# sourceMappingURL=operations.d.ts.map
+export declare type AnyOperation = Operation<AnyDialecteConfig>;