@dialecte/core 0.1.11 → 0.1.13

package/dist/test.js

@@ -1,153 +1,153 @@
 import { expect as f, it as p } from "vitest";
-import { x as X, D as q, i as S, o as D, e as h } from "./index-DRYqQRsA.js";
-import { DIALECTE_DEV_NAMESPACE as T, standardizeRecord as L, toTreeRecord as w, toTrackedRecord as g } from "./helpers.js";
-function v(t) {
-  const e = O(t);
-  if (e.length === 0)
-    return [t];
-  const a = [];
-  for (const B of e)
-    a.push(t.slice(0, B));
-  return a.push(t), a;
-}
-function O(t) {
+import { x as q, D as S, i as D, o as T, e as v } from "./index-MWde6dqY.js";
+import { D as L, s as w, o as g, n as O } from "./merge-extensions-BWXwiKx1.js";
+function E(a) {
+  const t = M(a);
+  if (t.length === 0)
+    return [a];
   const e = [];
-  let a = 0, B = 0, A = null;
-  for (let r = 0; r < t.length; r++) {
-    const _ = t[r];
-    if (A) {
-      _ === A && (A = null);
+  for (const A of t)
+    e.push(a.slice(0, A));
+  return e.push(a), e;
+}
+function M(a) {
+  const t = [];
+  let e = 0, A = 0, B = null;
+  for (let _ = 0; _ < a.length; _++) {
+    const C = a[_];
+    if (B) {
+      C === B && (B = null);
       continue;
     }
-    if (_ === '"' || _ === "'") {
-      A = _;
+    if (C === '"' || C === "'") {
+      B = C;
       continue;
     }
-    if (_ === "[") {
-      a++;
+    if (C === "[") {
+      e++;
       continue;
     }
-    if (_ === "]") {
-      a--;
+    if (C === "]") {
+      e--;
       continue;
     }
-    if (_ === "(") {
-      B++;
+    if (C === "(") {
+      A++;
       continue;
     }
-    if (_ === ")") {
-      B--;
+    if (C === ")") {
+      A--;
       continue;
     }
-    if (!(a > 0 || B > 0) && _ === "/") {
-      if (r === 0) {
-        t[r + 1] === "/" && r++;
+    if (!(e > 0 || A > 0) && C === "/") {
+      if (_ === 0) {
+        a[_ + 1] === "/" && _++;
         continue;
       }
-      if (e.length === 0 && r === 1 && t[0] === "/")
+      if (t.length === 0 && _ === 1 && a[0] === "/")
         continue;
-      e.push(r), t[r + 1] === "/" && r++;
+      t.push(_), a[_ + 1] === "/" && _++;
     }
   }
-  return e;
+  return t;
 }
-function M(t) {
-  const { namespaces: e } = t, a = R(e);
+function k(a) {
+  const { namespaces: t } = a, e = V(t);
   return {
-    assertExpectedElementQueries(B) {
-      k({ ...B, nsResolver: a });
+    assertExpectedElementQueries(A) {
+      R({ ...A, nsResolver: e });
     },
-    assertUnexpectedElementQueries(B) {
-      V({ ...B, nsResolver: a });
+    assertUnexpectedElementQueries(A) {
+      F({ ...A, nsResolver: e });
     }
   };
 }
-function k(t) {
-  const { xmlDocument: e, queries: a, nsResolver: B } = t;
-  for (const A of a)
-    F({ xmlDocument: e, xpath: A, nsResolver: B });
+function R(a) {
+  const { xmlDocument: t, queries: e, nsResolver: A } = a;
+  for (const B of e)
+    N({ xmlDocument: t, xpath: B, nsResolver: A });
 }
-function R(t) {
-  return (e) => e ? t[e]?.uri ?? null : null;
+function V(a) {
+  return (t) => t ? a[t]?.uri ?? null : null;
 }
-function V(t) {
-  const { xmlDocument: e, queries: a, nsResolver: B } = t;
-  for (const A of a)
-    N({ xmlDocument: e, xpath: A, nsResolver: B });
+function F(a) {
+  const { xmlDocument: t, queries: e, nsResolver: A } = a;
+  for (const B of e)
+    U({ xmlDocument: t, xpath: B, nsResolver: A });
 }
-function F(t) {
-  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
-  let r = null, _ = 0;
-  for (let C = 0; C < A.length; C++) {
-    const s = A[C], c = e.evaluate(
-      s,
-      e,
-      B ?? null,
+function N(a) {
+  const { xmlDocument: t, xpath: e, nsResolver: A } = a, B = E(e);
+  let _ = null, C = 0;
+  for (let s = 0; s < B.length; s++) {
+    const r = B[s], n = t.evaluate(
+      r,
+      t,
+      A ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
-    if (c) {
-      r = c, _ = C + 1;
+    if (n) {
+      _ = n, C = s + 1;
       continue;
     }
-    const i = C === 0 ? A[0] : a.slice(A[C - 1].length), u = _ === 0 ? `[No parent matched — failed from document root]
+    const c = s === 0 ? B[0] : e.slice(B[s - 1].length), u = C === 0 ? `[No parent matched — failed from document root]
   Document:
-${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${A.length}]:
-${r ? x({ xml: r.outerHTML }) : "(none)"}`;
+${x({ xml: new XMLSerializer().serializeToString(t) })}` : `[Last match at step ${C}/${B.length}]:
+${_ ? x({ xml: _.outerHTML }) : "(none)"}`;
     f(
-      c,
+      n,
       `Element not found in XML.
-  Failed at step ${C + 1}/${A.length}: ${i.trim()}
-  Full XPath: ${a}
+  Failed at step ${s + 1}/${B.length}: ${c.trim()}
+  Full XPath: ${e}
   ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function x(t) {
-  const { xml: e } = t;
+function x(a) {
+  const { xml: t } = a;
   try {
-    return X(e, { indentation: "  ", collapseContent: !0 });
+    return q(t, { indentation: "  ", collapseContent: !0 });
   } catch {
-    return e;
+    return t;
   }
 }
-function N(t) {
-  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
-  if (A.length > 1) {
-    let C = null;
-    for (let s = 0; s < A.length - 1; s++) {
-      const n = A[s], i = e.evaluate(
-        n,
-        e,
-        B ?? null,
+function U(a) {
+  const { xmlDocument: t, xpath: e, nsResolver: A } = a, B = E(e);
+  if (B.length > 1) {
+    let s = null;
+    for (let r = 0; r < B.length - 1; r++) {
+      const i = B[r], c = t.evaluate(
+        i,
+        t,
+        A ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, u = s === 0 ? A[0] : a.slice(A[s - 1].length), o = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
-${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+      ).singleNodeValue, u = r === 0 ? B[0] : e.slice(B[r - 1].length), l = r === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${r}]:
+${s ? x({ xml: s.outerHTML }) : "(none)"}`;
       f(
-        i,
+        c,
         `Absent assertion is unreliable: ancestor step does not exist.
   The query passes but for the wrong reason — an ancestor is missing, not the target element.
-  Missing at step ${s + 1}/${A.length}: ${u.trim()}
-  Full XPath: ${a}
-  ${o}`
-      ).toBeTruthy(), C = i;
+  Missing at step ${r + 1}/${B.length}: ${u.trim()}
+  Full XPath: ${e}
+  ${l}`
+      ).toBeTruthy(), s = c;
     }
   }
-  const _ = e.evaluate(
-    a,
+  const C = t.evaluate(
     e,
-    B ?? null,
+    t,
+    A ?? null,
     XPathResult.FIRST_ORDERED_NODE_TYPE,
     null
   ).singleNodeValue;
   f(
-    _,
+    C,
     `Element should NOT exist in XML but was found.
-  XPath: ${a}
+  XPath: ${e}
   Found:
-${_ ? x({ xml: _.outerHTML }) : "(none)"}`
+${C ? x({ xml: C.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
 const d = {
@@ -155,12 +155,12 @@ const d = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: T,
+  dev: L,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, Ae = `xmlns="${d.default.uri}"`, re = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, Ce = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, U = [
+}, re = `xmlns="${d.default.uri}"`, Ce = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, _e = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, y = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const d = {
   "CC_2",
   "CC_3",
   "Root"
-], y = {
+], I = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const d = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, I = {
+}, $ = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const d = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, $ = {
+}, P = {
   A: ["AAAA_1", "AAAA_2", "AAAA_3", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -319,7 +319,7 @@ const d = {
     "CC_2",
     "CC_3"
   ]
-}, P = {
+}, Q = {
   A: ["Root"],
   AAAA_1: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
   AAAA_2: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
@@ -351,7 +351,7 @@ const d = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, Q = "Root", z = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], G = {
+}, z = "Root", G = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], H = {
   A: {
     aA: "",
     bA: "",
@@ -506,7 +506,7 @@ const d = {
     "ext:root": "",
     root: ""
   }
-}, H = {
+}, j = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1508,168 +1508,182 @@ const d = {
       }
     ]
   }
-}, j = {
-  supportedFileExtensions: [".xml"]
 }, Y = {
+  supportedFileExtensions: [".xml"]
+}, W = {
   tables: {
     xmlElements: {
       name: "xmlElements",
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, l = {
-  rootElementName: Q,
-  singletonElements: z,
-  elements: U,
+}, o = {
+  rootElementName: z,
+  singletonElements: G,
+  elements: y,
   namespaces: d,
-  attributes: G,
-  children: y,
-  parents: I,
-  descendants: $,
-  ancestors: P,
-  database: Y,
-  io: j,
-  definition: H,
-  hooks: {}
+  attributes: H,
+  children: I,
+  parents: $,
+  descendants: P,
+  ancestors: Q,
+  database: W,
+  io: Y,
+  definition: j
 };
-async function m(t) {
-  const { xmlString: e, dialecteConfig: a = l } = t, B = `test-${crypto.randomUUID()}.xml`, A = new File([e], B, { type: "text/xml" }), _ = (await S({
-    files: [A],
-    dialecteConfig: a,
+async function m(a) {
+  const {
+    xmlString: t,
+    dialecteConfig: e = o,
+    hooks: A
+  } = a, B = `test-${crypto.randomUUID()}.xml`, _ = new File([t], B, { type: "text/xml" }), s = (await D({
+    files: [_],
+    dialecteConfig: e,
     useCustomRecordsIds: !0
-  }))[0], C = D({
-    config: a,
-    storage: { type: "local", databaseName: _ }
+  }))[0], r = T({
+    config: e,
+    storage: { type: "local", databaseName: s },
+    hooks: A
   });
   return {
-    document: C,
-    databaseName: _,
+    document: r,
+    databaseName: s,
     exportCurrentTest: async (c) => {
-      const { extension: i = a.io.supportedFileExtensions[0], withDatabaseIds: u = !1 } = c || {};
-      return h({
-        dialecteConfig: a,
-        databaseName: _,
-        extension: i,
-        withDatabaseIds: u
+      const { extension: u = e.io.supportedFileExtensions[0], withDatabaseIds: l = !1 } = c || {};
+      return v({
+        dialecteConfig: e,
+        databaseName: s,
+        extension: u,
+        withDatabaseIds: l
       });
     },
     cleanup: async () => {
-      C.destroy();
+      r.destroy();
     }
   };
 }
-function _e(t) {
-  const { databaseName: e, dialecteConfig: a } = t;
+function se(a) {
+  const { databaseName: t, dialecteConfig: e } = a;
   return {
-    store: new q(e, a),
+    store: new S(t, e),
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const E = crypto.randomUUID.bind(crypto);
-function b() {
-  let t = 0;
+const b = crypto.randomUUID.bind(crypto);
+function X() {
+  let a = 0;
   return function() {
-    return `${t++}`;
+    return `${a++}`;
   };
 }
-function W(t) {
+function Z(a) {
   const {
-    testCases: e,
-    act: a,
-    dialecteConfig: B = l
-  } = t, { assertExpectedElementQueries: A, assertUnexpectedElementQueries: r } = M({
+    testCases: t,
+    act: e,
+    hooks: A,
+    dialecteConfig: B = o
+  } = a, { assertExpectedElementQueries: _, assertUnexpectedElementQueries: C } = k({
     namespaces: B.namespaces
   });
-  for (const [_, C] of Object.entries(e))
-    (C.only ? p.only : p)(_, async () => {
-      crypto.randomUUID = E;
-      const n = await m({ xmlString: C.sourceXml, dialecteConfig: B }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: B }) : void 0;
+  for (const [s, r] of Object.entries(t))
+    (r.only ? p.only : p)(s, async () => {
+      crypto.randomUUID = b;
+      const n = await m({
+        xmlString: r.sourceXml,
+        dialecteConfig: B,
+        hooks: A
+      }), c = r.targetXml ? await m({ xmlString: r.targetXml, dialecteConfig: B, hooks: A }) : void 0;
       try {
-        crypto.randomUUID = b();
-        const { assertDatabaseName: i, withDatabaseIds: u } = await a({
-          testCase: C,
+        crypto.randomUUID = X();
+        const { assertDatabaseName: u, withDatabaseIds: l } = await e({
+          testCase: r,
           source: { document: n.document, databaseName: n.databaseName },
           target: c ? { document: c.document, databaseName: c.databaseName } : void 0
-        }), { xmlDocument: o } = await h({
+        }), { xmlDocument: h } = await v({
           dialecteConfig: B,
-          databaseName: i,
+          databaseName: u,
           extension: B.io.supportedFileExtensions[0],
-          withDatabaseIds: u ?? !0
+          withDatabaseIds: l ?? !0
         });
-        C.expectedQueries?.length && A({ xmlDocument: o, queries: C.expectedQueries }), C.unexpectedQueries?.length && r({ xmlDocument: o, queries: C.unexpectedQueries });
+        r.expectedQueries?.length && _({ xmlDocument: h, queries: r.expectedQueries }), r.unexpectedQueries?.length && C({ xmlDocument: h, queries: r.unexpectedQueries });
       } finally {
         await n.cleanup(), await c?.cleanup();
       }
     });
 }
-function Z(t) {
+function J(a) {
   const {
-    testCases: e,
-    act: a,
-    dialecteConfig: B = l
-  } = t;
-  for (const [A, r] of Object.entries(e))
-    (r.only ? p.only : p)(A, async () => {
-      crypto.randomUUID = E;
-      const C = await m({ xmlString: r.sourceXml, dialecteConfig: B }), s = r.targetXml ? await m({ xmlString: r.targetXml, dialecteConfig: B }) : void 0;
+    testCases: t,
+    act: e,
+    hooks: A,
+    dialecteConfig: B = o
+  } = a;
+  for (const [_, C] of Object.entries(t))
+    (C.only ? p.only : p)(_, async () => {
+      crypto.randomUUID = b;
+      const r = await m({
+        xmlString: C.sourceXml,
+        dialecteConfig: B,
+        hooks: A
+      }), i = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: B, hooks: A }) : void 0;
       try {
-        crypto.randomUUID = b(), await a({
-          testCase: r,
-          source: { document: C.document, databaseName: C.databaseName },
-          target: s ? { document: s.document, databaseName: s.databaseName } : void 0
+        crypto.randomUUID = X(), await e({
+          testCase: C,
+          source: { document: r.document, databaseName: r.databaseName },
+          target: i ? { document: i.document, databaseName: i.databaseName } : void 0
         });
       } finally {
-        await C.cleanup(), await s?.cleanup();
+        await r.cleanup(), await i?.cleanup();
       }
     });
 }
-function J(t, e) {
-  for (const [a, B] of Object.entries(t))
-    (B.only ? p.only : p)(a, () => e(B));
+function K(a, t) {
+  for (const [e, A] of Object.entries(a))
+    (A.only ? p.only : p)(e, () => t(A));
 }
-const se = K(l);
-function K(t) {
+const ce = ee(o);
+function ee(a, t) {
   return {
-    withExport: (e) => W({ dialecteConfig: t, ...e }),
-    withoutExport: (e) => Z({ dialecteConfig: t, ...e }),
-    generic: J
+    withExport: (e) => Z({ dialecteConfig: a, hooks: t, ...e }),
+    withoutExport: (e) => J({ dialecteConfig: a, hooks: t, ...e }),
+    generic: K
   };
 }
-function ee(t) {
-  function e(a) {
-    const { record: B, type: A = "raw" } = a, r = L({ record: B, dialecteConfig: t });
-    switch (A) {
+function te(a) {
+  function t(e) {
+    const { record: A, type: B = "raw" } = e, _ = w({ record: A, dialecteConfig: a });
+    switch (B) {
       case "raw":
-        return r;
+        return _;
       case "tracked":
-        return g({ record: r });
+        return O({ record: _ });
       case "tree":
-        return w({ record: r });
+        return g({ record: _ });
       default:
-        throw new Error(`Unsupported record type: ${A}`);
+        throw new Error(`Unsupported record type: ${B}`);
     }
   }
-  return e;
+  return t;
 }
-const ce = ee(l);
+const ie = te(o);
 export {
-  Y as DATABASE_CONFIG,
+  W as DATABASE_CONFIG,
   d as DIALECTE_NAMESPACES,
-  j as IO_CONFIG,
-  l as TEST_DIALECTE_CONFIG,
-  Ae as XMLNS_DEFAULT_NAMESPACE,
-  re as XMLNS_DEV_NAMESPACE,
-  Ce as XMLNS_EXT_NAMESPACE,
-  k as assertExpectedElementQueries,
-  V as assertUnexpectedElementQueries,
-  b as createMockRandomUUID,
-  _e as createTestContext,
+  Y as IO_CONFIG,
+  o as TEST_DIALECTE_CONFIG,
+  re as XMLNS_DEFAULT_NAMESPACE,
+  Ce as XMLNS_DEV_NAMESPACE,
+  _e as XMLNS_EXT_NAMESPACE,
+  R as assertExpectedElementQueries,
+  F as assertUnexpectedElementQueries,
+  X as createMockRandomUUID,
+  se as createTestContext,
   m as createTestDialecte,
-  ce as createTestRecord,
-  ee as createTestRecordFactory,
-  K as createTestRunner,
-  M as createXmlAssertions,
-  se as runTestCases,
-  v as splitXpathIntoSteps
+  ie as createTestRecord,
+  te as createTestRecordFactory,
+  ee as createTestRunner,
+  k as createXmlAssertions,
+  ce as runTestCases,
+  E as splitXpathIntoSteps
 };

package/dist/types/dialecte-config.d.ts

@@ -16,7 +16,6 @@ export type RawDialecteConfig<GenericElementNames extends readonly string[], Gen
     database: DatabaseConfig;
     io: IOConfig;
     definition: AnyDefinition;
-    hooks: TransactionHooks;
 };
 export type IOConfig = {
     supportedFileExtensions: readonly string[];
@@ -24,12 +23,12 @@ export type IOConfig = {
     exportOptions?: Partial<ExportOptions>;
     hooks?: IOHooks;
 };
-export type TransactionHooks = {
+export type TransactionHooks<GenericConfig extends AnyDialecteConfig> = {
     /**
      * Called before cloning a record.
      * Return modified attributes for the clone.
      */
-    beforeClone?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    beforeClone?: <GenericElement extends ElementsOf<GenericConfig>>(params: {
         record: TreeRecord<GenericConfig, GenericElement>;
     }) => {
         shouldBeCloned: boolean;
@@ -39,31 +38,31 @@ export type TransactionHooks = {
      * Called after core standardizes element from definition.
      * Use to enrich record (e.g., auto-generate UUIDs).
      */
-    afterStandardizedRecord?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    afterStandardizedRecord?: <GenericElement extends ElementsOf<GenericConfig>>(params: {
         record: RawRecord<GenericConfig, GenericElement>;
     }) => RawRecord<GenericConfig, GenericElement>;
     /**
      * Called after record created but before staging.
      * Return additional operations (e.g., wrapper elements).
      */
-    afterCreated?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(params: {
+    afterCreated?: <GenericElement extends ElementsOf<GenericConfig>, GenericParentElement extends ParentsOf<GenericConfig, GenericElement>>(params: {
         childRecord: RawRecord<GenericConfig, GenericElement>;
         parentRecord: RawRecord<GenericConfig, GenericParentElement>;
         query: Query<GenericConfig>;
     }) => Promise<Operation<GenericConfig>[]>;
     /**
      * Called after deepClone completes all recursive cloning.
-     * Receives the full source→target mapping. Return additional operations to stage
+     * Receives the full source->target mapping. Return additional operations to stage
      */
-    afterDeepClone?: <GenericConfig extends AnyDialecteConfig>(params: {
-        mappings: CloneMapping<GenericConfig>[];
+    afterDeepClone?: (params: {
+        cumulativeCloneMappings: CloneMapping<GenericConfig>[];
         query: Query<GenericConfig>;
     }) => Promise<Operation<GenericConfig>[]>;
     /**
      * Called after a record is updated (attributes or value changed).
      * Return additional operations to stage (e.g., update path attrs on dependent refs).
      */
-    afterUpdated?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    afterUpdated?: <GenericElement extends ElementsOf<GenericConfig>>(params: {
         oldRecord: RawRecord<GenericConfig, GenericElement>;
         newRecord: RawRecord<GenericConfig, GenericElement>;
         query: Query<GenericConfig>;
@@ -75,7 +74,7 @@ export type TransactionHooks = {
      * Return additional operations to stage (e.g., clear or delete ref elements
      * pointing to this record or any of its descendants).
      */
-    beforeDelete?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+    beforeDelete?: <GenericElement extends ElementsOf<GenericConfig>>(params: {
         record: RawRecord<GenericConfig, GenericElement>;
         query: Query<GenericConfig>;
     }) => Promise<Operation<GenericConfig>[]>;