@dialecte/core 0.6.4 → 0.8.0

package/dist/test/fixtures/test-entry-scan-edges.types.d.ts

@@ -0,0 +1,10 @@
+/** What the scan fixture of edge cases names: exported here, never by the fixture module the scan reads. */
+export type EdgeRow = {
+    value: string;
+};
+/** A generic that expands on every level (`Tree<T>` holds `Tree<T[]>`): a scan that follows it naively never ends. */
+export type Tree<GenericLeaf> = {
+    leaf: GenericLeaf;
+    children: Tree<GenericLeaf[]>[];
+};
+//# sourceMappingURL=test-entry-scan-edges.types.d.ts.map

package/dist/test/fixtures/test-entry-scan-edges.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-edges.types.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-edges.types.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,MAAM,MAAM,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC,sHAAsH;AACtH,MAAM,MAAM,IAAI,CAAC,WAAW,IAAI;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,CAAA;CAAE,CAAA"}

package/dist/test/fixtures/test-entry-scan-recursive.d.ts

@@ -0,0 +1,4 @@
+import { Recursive, RecursiveInterface } from './test-entry-scan-recursive.types';
+export declare function startRecursive(): Recursive<number> | undefined;
+export declare function startRecursiveInterface(): RecursiveInterface<number> | undefined;
+//# sourceMappingURL=test-entry-scan-recursive.d.ts.map

package/dist/test/fixtures/test-entry-scan-recursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-recursive.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-recursive.ts"],"names":[],"mappings":"AAAA,yGAAyG;AAEzG,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAEtF,wBAAgB,cAAc,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAE9D;AAED,wBAAgB,uBAAuB,IAAI,kBAAkB,CAAC,MAAM,CAAC,GAAG,SAAS,CAEhF"}

package/dist/test/fixtures/test-entry-scan-recursive.types.d.ts

@@ -0,0 +1,15 @@
+/** What the scan fixture of self-referencing generics names: exported here, never by the fixture module the scan reads. */
+export type DeepRow = {
+    value: string;
+};
+/** Names `DeepRow` only at its second level: `Recursive<number>` holds `Recursive<string>`. */
+export type Recursive<GenericValue> = {
+    value: GenericValue extends string ? DeepRow : never;
+    next: Recursive<string>;
+};
+/** The same, as an interface. */
+export interface RecursiveInterface<GenericValue> {
+    value: GenericValue extends string ? DeepRow : never;
+    next: RecursiveInterface<string>;
+}
+//# sourceMappingURL=test-entry-scan-recursive.types.d.ts.map

package/dist/test/fixtures/test-entry-scan-recursive.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-recursive.types.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-recursive.types.ts"],"names":[],"mappings":"AAAA,2HAA2H;AAC3H,MAAM,MAAM,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC,+FAA+F;AAC/F,MAAM,MAAM,SAAS,CAAC,YAAY,IAAI;IACrC,KAAK,EAAE,YAAY,SAAS,MAAM,GAAG,OAAO,GAAG,KAAK,CAAA;IACpD,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;CACvB,CAAA;AAED,iCAAiC;AACjC,MAAM,WAAW,kBAAkB,CAAC,YAAY;IAC/C,KAAK,EAAE,YAAY,SAAS,MAAM,GAAG,OAAO,GAAG,KAAK,CAAA;IACpD,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAA;CAChC"}

package/dist/test/fixtures/test-entry-scan-shapes.d.ts

@@ -0,0 +1,14 @@
+import { Box, ShapeRow, Tagged } from './test-entry-scan-shapes.types';
+export declare function indexShapeRows(): {
+    [key: string]: ShapeRow;
+};
+export declare function listShapeRowsByNumber(): {
+    [position: number]: ShapeRow;
+};
+export declare function pickShapeRow<GenericRow extends ShapeRow>(params: {
+    row: GenericRow;
+}): string;
+export declare function emptyShapeRows<GenericRow = ShapeRow>(): GenericRow[];
+export declare function tagShapeRow(): Tagged<ShapeRow>;
+export declare function boxShapeRow(): Box<ShapeRow>;
+//# sourceMappingURL=test-entry-scan-shapes.d.ts.map

package/dist/test/fixtures/test-entry-scan-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-shapes.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-shapes.ts"],"names":[],"mappings":"AAAA,gHAAgH;AAEhH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAA;AAE3E,wBAAgB,cAAc,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAE5D;AAED,wBAAgB,qBAAqB,IAAI;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAExE;AAED,wBAAgB,YAAY,CAAC,UAAU,SAAS,QAAQ,EAAE,MAAM,EAAE;IAAE,GAAG,EAAE,UAAU,CAAA;CAAE,GAAG,MAAM,CAE7F;AAED,wBAAgB,cAAc,CAAC,UAAU,GAAG,QAAQ,KAAK,UAAU,EAAE,CAEpE;AAED,wBAAgB,WAAW,IAAI,MAAM,CAAC,QAAQ,CAAC,CAE9C;AAED,wBAAgB,WAAW,IAAI,GAAG,CAAC,QAAQ,CAAC,CAE3C"}

package/dist/test/fixtures/test-entry-scan-shapes.types.d.ts

@@ -0,0 +1,14 @@
+/** What the scan fixture of other type shapes names: exported here, never by the fixture module the scan reads. */
+export type ShapeRow = {
+    value: string;
+};
+/** A generic of the test entry that reads its parameter through a member (`brand`): reached either way. */
+export type Box<GenericContent> = {
+    id: string;
+    brand?: (content: GenericContent) => never;
+};
+/** A generic of the test entry that never reads its parameter (a phantom one): reached only as a type argument. */
+export interface Tagged<_GenericTag> {
+    label: string;
+}
+//# sourceMappingURL=test-entry-scan-shapes.types.d.ts.map

package/dist/test/fixtures/test-entry-scan-shapes.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-shapes.types.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-shapes.types.ts"],"names":[],"mappings":"AAAA,mHAAmH;AACnH,MAAM,MAAM,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAExC,2GAA2G;AAC3G,MAAM,MAAM,GAAG,CAAC,cAAc,IAAI;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,KAAK,CAAA;CAAE,CAAA;AAE5F,mHAAmH;AACnH,MAAM,WAAW,MAAM,CAAC,WAAW;IAClC,KAAK,EAAE,MAAM,CAAA;CACb"}

package/dist/test/fixtures/test-entry-scan-tree.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from './test-entry-scan-edges.types';
+export declare function plantTree(): Tree<string> | undefined;
+//# sourceMappingURL=test-entry-scan-tree.d.ts.map

package/dist/test/fixtures/test-entry-scan-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-tree.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-tree.ts"],"names":[],"mappings":"AAAA,iGAAiG;AAEjG,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAA;AAEzD,wBAAgB,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,CAEpD"}

package/dist/test/fixtures/test-entry-scan.d.ts

@@ -0,0 +1,5 @@
+import { HiddenRow } from './test-entry-scan.types';
+export declare function listHiddenRows(): HiddenRow[];
+export declare function loadHiddenRow(): Promise<HiddenRow>;
+export declare function indexHiddenRows(): Record<string, HiddenRow>;
+//# sourceMappingURL=test-entry-scan.d.ts.map

package/dist/test/fixtures/test-entry-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan.ts"],"names":[],"mappings":"AAAA,uHAAuH;AAGvH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,wBAAgB,cAAc,IAAI,SAAS,EAAE,CAE5C;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,SAAS,CAAC,CAExD;AAED,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAE3D"}

package/dist/test/fixtures/test-entry-scan.types.d.ts

@@ -0,0 +1,5 @@
+/** A row the scan fixture's functions return: exported here, never by the fixture module the scan reads. */
+export type HiddenRow = {
+    value: string;
+};
+//# sourceMappingURL=test-entry-scan.types.d.ts.map

package/dist/test/fixtures/test-entry-scan.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan.types.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan.types.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/dist/test/generated/definition.generated.d.ts

@@ -1533,6 +1533,7 @@ export declare const DEFINITION: {
         };
         readonly children: {
             readonly sequence: readonly ["CCC_1", "CCC_2", "CCC_3"];
+            readonly any: true;
             readonly details: {};
         };
         readonly contentModel: {
@@ -1540,6 +1541,10 @@ export declare const DEFINITION: {
             readonly minOccurs: 1;
             readonly maxOccurs: 1;
             readonly particles: readonly [{
+                readonly kind: "any";
+                readonly notNamespace: readonly ["", "http://dialecte.dev/XML/DEFAULT"];
+                readonly processContents: "lax";
+            }, {
                 readonly kind: "element";
                 readonly name: "CCC_1";
                 readonly minOccurs: 1;

package/dist/test/generated/definition.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.generated.d.ts","sourceRoot":"","sources":["../../../src/test/generated/definition.generated.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAy/Cb,CAAA;AAEV,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqUR,CAAA"}
+{"version":3,"file":"definition.generated.d.ts","sourceRoot":"","sources":["../../../src/test/generated/definition.generated.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+/Cb,CAAA;AAEV,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqUR,CAAA"}

package/dist/test/in-memory-storage.setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory-storage.setup.d.ts.map

package/dist/test/in-memory-storage.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-storage.setup.d.ts","sourceRoot":"","sources":["../../src/test/in-memory-storage.setup.ts"],"names":[],"mappings":""}

package/dist/test/index.d.ts

@@ -3,9 +3,15 @@ export * from './assert-xml';
 export * from './config';
 export * from './constant';
 export * from './create-test-dialecte';
+export type * from './create-test-dialecte.types';
+export * from './create-test-helpers';
+export type * from './create-test-helpers.types';
 export * from './normalize-uuids';
 export * from './run-test-cases';
+export * from './test-dialecte';
+export type * from './test-dialecte.types';
 export type * from './run-test-cases.type';
 export * from './test-record';
+export { useTestStorage } from './test-storage';
 export type * from './test-record.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/test/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,mBAAmB,uBAAuB,CAAA;AAC1C,cAAc,eAAe,CAAA;AAC7B,mBAAmB,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,mBAAmB,8BAA8B,CAAA;AACjD,cAAc,uBAAuB,CAAA;AACrC,mBAAmB,6BAA6B,CAAA;AAChD,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,mBAAmB,uBAAuB,CAAA;AAC1C,mBAAmB,uBAAuB,CAAA;AAC1C,cAAc,eAAe,CAAA;AAC7B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,mBAAmB,qBAAqB,CAAA"}

package/dist/test/normalize-uuids.constants.d.ts

@@ -0,0 +1,3 @@
+/** A uuid in its canonical textual form, any case, matched everywhere in a text. */
+export declare const UUID_PATTERN: RegExp;
+//# sourceMappingURL=normalize-uuids.constants.d.ts.map

package/dist/test/normalize-uuids.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-uuids.constants.d.ts","sourceRoot":"","sources":["../../src/test/normalize-uuids.constants.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,eAAO,MAAM,YAAY,QAAmE,CAAA"}

package/dist/test/normalize-uuids.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Replace every uuid value in a serialized document with a stable, first-appearance token
+ * (`uuid-1`, `uuid-2`, …). The same uuid always maps to the same token, so relationships — a
+ * `templateUuid` pointing at an element's `uuid`, a reference's target — stay visible, while the
+ * result no longer depends on the random uuid VALUES.
+ *
+ * Use it to freeze a document `snapshot` on structure + lineage without mocking `crypto.randomUUID`:
+ * `expect(normalizeUuids(xml)).toMatchSnapshot()`. A real structural or lineage change still moves the
+ * snapshot; only the opaque random values are tokenized.
+ *
+ * @intent snapshot a document independently of random uuids, compare XML holding generated ids
+ */
 export declare function normalizeUuids(text: string): string;
 //# sourceMappingURL=normalize-uuids.d.ts.map

package/dist/test/normalize-uuids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-uuids.d.ts","sourceRoot":"","sources":["../../src/test/normalize-uuids.ts"],"names":[],"mappings":"AAYA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASnD"}
+{"version":3,"file":"normalize-uuids.d.ts","sourceRoot":"","sources":["../../src/test/normalize-uuids.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASnD"}

package/dist/test/run-test-cases.d.ts

@@ -1,7 +1,29 @@
-import { TestRunner } from './run-test-cases.type';
+import { DeclaredTestRunnerParams, LegacyTestRunnerParams } from './create-test-dialecte.types';
+import { CreateMockRandomUuidParams, TestRunner } from './run-test-cases.type';
 import { ExtensionModules } from '../document';
-import { AnyDialecteConfig, DialecteHooks } from '../types';
-export declare function createMockRandomUUID(): () => `${string}-${string}-${string}-${string}-${string}`;
+import { AnyDialecteConfig } from '../types';
+import { UuidShaped } from '../utils';
+/**
+ * The `crypto.randomUUID` a test case's act runs with: UUID-shaped ids that follow from a seed (0 by
+ * default), the same sequence on every run.
+ *
+ * @intent get deterministic uuids in a test, mock crypto.randomUUID
+ */
+export declare function createMockRandomUUID(params?: CreateMockRandomUuidParams): () => UuidShaped;
+/**
+ * The test runner of a declared dialecte: each case runs on a fresh project with every config,
+ * the default key, the dialecte's extensions and its own hooks instance, on the store `storage`
+ * names (the local one by default).
+ *
+ * @intent run table-driven test cases on a dialecte, test a transaction against expected XML
+ */
+export declare function createTestRunner<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string>(params: DeclaredTestRunnerParams<GenericConfig, GenericModules, GenericConfigKey>): TestRunner<GenericConfig, GenericModules>;
+/**
+ * A test runner from a config, extensions and one hooks instance shared by every case.
+ * @deprecated Declare the dialecte with `defineDialecte` and pass it as `dialecte`.
+ */
+export declare function createTestRunner<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: LegacyTestRunnerParams<GenericConfig>): TestRunner<GenericConfig, GenericModules>;
+/** Core's own runner: the declared test dialecte on the local store. */
 export declare const runTestCases: TestRunner<{
     readonly rootElementName: "Root";
     readonly singletonElements: readonly ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "D", "DDD_1", "DD_1", "Root"];
@@ -1903,6 +1925,7 @@ export declare const runTestCases: TestRunner<{
             };
             readonly children: {
                 readonly sequence: readonly ["CCC_1", "CCC_2", "CCC_3"];
+                readonly any: true;
                 readonly details: {};
             };
             readonly contentModel: {
@@ -1910,6 +1933,10 @@ export declare const runTestCases: TestRunner<{
                 readonly minOccurs: 1;
                 readonly maxOccurs: 1;
                 readonly particles: readonly [{
+                    readonly kind: "any";
+                    readonly notNamespace: readonly ["", "http://dialecte.dev/XML/DEFAULT"];
+                    readonly processContents: "lax";
+                }, {
                     readonly kind: "element";
                     readonly name: "CCC_1";
                     readonly minOccurs: 1;
@@ -2717,12 +2744,4 @@ export declare const runTestCases: TestRunner<{
         };
     };
 }, Record<never, never>>;
-export declare function createTestRunner<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: {
-    dialecteConfig: GenericConfig;
-    hooks?: DialecteHooks<GenericConfig>;
-    extensions?: {
-        base?: ExtensionModules;
-        custom?: ExtensionModules;
-    };
-}): TestRunner<GenericConfig, GenericModules>;
 //# sourceMappingURL=run-test-cases.d.ts.map

package/dist/test/run-test-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAMX,UAAU,EACV,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAQ/D,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AAgJD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA6D,CAAA;AAEtF,wBAAgB,gBAAgB,CAC/B,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7D,MAAM,EAAE;IACT,cAAc,EAAE,aAAa,CAAA;IAC7B,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACpC,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;KAAE,CAAA;CACnE,GAAG,UAAU,CAAC,aAAa,EAAE,cAAc,CAAC,CAO5C"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AACpG,OAAO,KAAK,EAMX,0BAA0B,EAC1B,UAAU,EACV,MAAM,uBAAuB,CAAA;AAE9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAMzC;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,0BAA0B,GAAG,MAAM,UAAU,CAE1F;AAwID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC9D,gBAAgB,SAAS,MAAM,GAAG,MAAM,EAExC,MAAM,EAAE,wBAAwB,CAAC,aAAa,EAAE,cAAc,EAAE,gBAAgB,CAAC,GAC/E,UAAU,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;AAC5C;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7D,MAAM,EAAE,sBAAsB,CAAC,aAAa,CAAC,GAAG,UAAU,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;AAe3F,wEAAwE;AACxE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgD,CAAA"}

package/dist/test/run-test-cases.type.d.ts

@@ -33,6 +33,12 @@ export type TestRunner<GenericConfig extends AnyDialecteConfig, GenericModules e
     withExport<GenericTestCase extends BaseXmlTestCase>(params: {
         testCases: TestCases<GenericTestCase>;
         act: (params: ActParams<GenericConfig, GenericTestCase, GenericModules>) => Promise<ActResult | void>;
+        /**
+         * The declared config the cases are imported under (and checked against, by the dialecte's
+         * test helpers). Defaults to the default key.
+         */
+        configKey?: string;
+        /** Replaces the config under `configKey` (the default one when no key is given). */
         dialecteConfig?: GenericConfig;
         hooks?: DialecteHooks<GenericConfig>;
         /** Project dev options; `perf: true` makes `document.perf.report()` count the store reads. */
@@ -43,6 +49,12 @@ export type TestRunner<GenericConfig extends AnyDialecteConfig, GenericModules e
     withoutExport<GenericTestCase extends BaseXmlTestCase>(params: {
         testCases: TestCases<GenericTestCase>;
         act: (params: ActParams<GenericConfig, GenericTestCase, GenericModules>) => Promise<void>;
+        /**
+         * The declared config the cases are imported under (and checked against, by the dialecte's
+         * test helpers). Defaults to the default key.
+         */
+        configKey?: string;
+        /** Replaces the config under `configKey` (the default one when no key is given). */
         dialecteConfig?: GenericConfig;
         hooks?: DialecteHooks<GenericConfig>;
         /** Project dev options; `perf: true` makes `document.perf.report()` count the store reads. */
@@ -52,4 +64,8 @@ export type TestRunner<GenericConfig extends AnyDialecteConfig, GenericModules e
     }): void;
     generic<GenericTestCase extends BaseTestCase>(testCases: Record<string, GenericTestCase>, act: (testCase: GenericTestCase) => void): void;
 };
+/** What `createMockRandomUUID` is given: the seed of its sequence, 0 when absent. */
+export type CreateMockRandomUuidParams = {
+    seed?: number;
+};
 //# sourceMappingURL=run-test-cases.type.d.ts.map

package/dist/test/run-test-cases.type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"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"}

package/dist/test/sqlite-storage.setup.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=sqlite-storage.setup.d.ts.map

package/dist/test/sqlite-storage.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-storage.setup.d.ts","sourceRoot":"","sources":["../../src/test/sqlite-storage.setup.ts"],"names":[],"mappings":"AAEA,OAAO,UAAU,CAAA"}

package/dist/test/test-dialecte-setup.d.ts

@@ -0,0 +1,31 @@
+import { DeclaredTestDialecteParams, LegacyTestDialecteParams, TestProjectOptions, TestProjectResult } from './create-test-dialecte.types';
+import { ResolveTestConfigParams, TestDialecteSetup } from './test-dialecte-setup.types';
+import { ExtensionModules } from '../document';
+import { AnyDialecteConfig, DialecteHooks } from '../types';
+/** The setup behind either form: the declaration given, core's own, or one made from the parts. */
+export declare function resolveTestDialecte<GenericConfig extends AnyDialecteConfig>(params: Partial<DeclaredTestDialecteParams<GenericConfig, ExtensionModules, string>> | LegacyTestDialecteParams<GenericConfig>): TestDialecteSetup<GenericConfig>;
+/**
+ * The declared config under `configKey` (the default config when no key is given). An unknown key
+ * is refused with `UNKNOWN_CONFIG_KEY` before any store is touched.
+ */
+export declare function resolveTestConfig<GenericConfig extends AnyDialecteConfig>(params: ResolveTestConfigParams<GenericConfig>): {
+    configKey: string;
+    config: GenericConfig;
+};
+/** The setup with a case's own config (under `configKey`, else the default key) or hooks. */
+export declare function overrideTestDialecte<GenericConfig extends AnyDialecteConfig>(params: {
+    setup: TestDialecteSetup<GenericConfig>;
+    configKey?: string;
+    dialecteConfig?: GenericConfig;
+    hooks?: DialecteHooks<GenericConfig>;
+}): TestDialecteSetup<GenericConfig>;
+/**
+ * Open a test project on the setup, with the source (and the target, when given) imported under
+ * the default config. Opened inside a running test (its body or a `beforeEach`), the project is
+ * destroyed when that test ends; opened outside one (`beforeAll`, module scope), the caller owns
+ * its lifecycle: `project.destroy()`. A destroy by the caller as well is harmless.
+ */
+export declare function openTestProject<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: TestProjectOptions & {
+    setup: TestDialecteSetup<GenericConfig>;
+}): Promise<TestProjectResult<GenericConfig, GenericModules>>;
+//# sourceMappingURL=test-dialecte-setup.d.ts.map

package/dist/test/test-dialecte-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-dialecte-setup.d.ts","sourceRoot":"","sources":["../../src/test/test-dialecte-setup.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACX,0BAA0B,EAC1B,wBAAwB,EAExB,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE/D,mGAAmG;AACnG,wBAAgB,mBAAmB,CAAC,aAAa,SAAS,iBAAiB,EAC1E,MAAM,EACH,OAAO,CAAC,0BAA0B,CAAC,aAAa,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAC5E,wBAAwB,CAAC,aAAa,CAAC,GACxC,iBAAiB,CAAC,aAAa,CAAC,CAsBlC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EACxE,MAAM,EAAE,uBAAuB,CAAC,aAAa,CAAC,GAC5C;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,CAU9C;AAED,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACrF,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAA;IACvC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;CACpC,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAkBnC;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACpC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAE9D,MAAM,EAAE,kBAAkB,GAAG;IAAE,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAA;CAAE,GACtE,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CA6B3D"}

package/dist/test/test-dialecte-setup.types.d.ts

@@ -0,0 +1,29 @@
+import { DialecteDeclaration } from '../dialecte';
+import { ExtensionModules } from '../document';
+import { StorageParam } from '../project';
+import { AnyDialecteConfig, DialecteHooks } from '../types';
+/** What a test project is built from: a declaration, and the consumer's own modules when given. */
+export type TestDialecteSetup<GenericConfig extends AnyDialecteConfig> = {
+    dialecte: DialecteDeclaration<GenericConfig, ExtensionModules, string>;
+    custom?: ExtensionModules;
+};
+/** What a runner holds for every case: the dialecte setup and the store the projects run on. */
+export type RunnerSetup<GenericConfig extends AnyDialecteConfig> = {
+    setup: TestDialecteSetup<GenericConfig>;
+    storage?: StorageParam;
+};
+/** What one `withExport` / `withoutExport` call may put in place of the runner's. */
+export type CaseOverrides<GenericConfig extends AnyDialecteConfig> = {
+    configKey?: string;
+    dialecteConfig?: GenericConfig;
+    hooks?: DialecteHooks<GenericConfig>;
+    dev?: {
+        perf?: boolean;
+    };
+};
+/** A config of the setup by its key; the default config when no key is given. */
+export type ResolveTestConfigParams<GenericConfig extends AnyDialecteConfig> = {
+    setup: TestDialecteSetup<GenericConfig>;
+    configKey: string | undefined;
+};
+//# sourceMappingURL=test-dialecte-setup.types.d.ts.map

package/dist/test/test-dialecte-setup.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-dialecte-setup.types.d.ts","sourceRoot":"","sources":["../../src/test/test-dialecte-setup.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE/D,mGAAmG;AACnG,MAAM,MAAM,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACxE,QAAQ,EAAE,mBAAmB,CAAC,aAAa,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAA;IACtE,MAAM,CAAC,EAAE,gBAAgB,CAAA;CACzB,CAAA;AAED,gGAAgG;AAChG,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAA;IACvC,OAAO,CAAC,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,qFAAqF;AACrF,MAAM,MAAM,aAAa,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACpE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACpC,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CACxB,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,uBAAuB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAC9E,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAA;IACvC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B,CAAA"}