clivly 0.7.4 → 0.9.0

package/drizzle-kBULBAOa.d.mts

@@ -0,0 +1,41 @@
+import { d as DiscoveredSchemaTable, u as DiscoveredColumnMeta } from "./entity-config-C4Yf_fPj.mjs";
+import { Table } from "drizzle-orm";
+//#region ../core/src/drizzle.d.ts
+/**
+ * Every unique key on a table, as DB column-name tuples. Primary keys count —
+ * fan-out detection asks "do these join columns cover a unique key?", and a PK
+ * answers that as well as any explicit unique constraint.
+ *
+ * Returns `undefined` if reflection fails (non-pg table, or a drizzle version
+ * without config access), meaning "unknown, cannot determine". Returns `[]`
+ * when reflection succeeds and the table genuinely has none. That distinction
+ * is load-bearing: `hasRichMeta` uses it to tell "metadata unavailable" from
+ * "confirmed no constraints", and projection validation fails closed on the
+ * former.
+ */
+declare function buildUniqueConstraints(table: unknown): string[][] | undefined;
+/**
+ * Per-column metadata (type, PK, nullability, FK edges) for a Drizzle table.
+ * Structural only — no DB round-trip, so it is safe to recompute on every
+ * heartbeat. FK reflection is best-effort; a non-Postgres table still gets
+ * name/type/PK/nullable.
+ */
+declare function buildColumnsMeta(table: Table): DiscoveredColumnMeta[];
+/**
+ * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
+ * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
+ * delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
+ * `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
+ * against your entity config.
+ *
+ * Column names are the real database column names (e.g. `full_name`), not the
+ * Drizzle property keys (`fullName`). Non-table values in the schema object
+ * (relations, enums, helpers) are ignored.
+ *
+ * `drizzle-orm` is an **optional peer dependency** — you only need it installed
+ * when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
+ * stays dependency-free.
+ */
+declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
+//#endregion
+export { buildUniqueConstraints as n, discoverFromDrizzle as r, buildColumnsMeta as t };

package/drizzle.cjs

@@ -1,43 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_drizzle_meta = require("./drizzle-meta-Bb1JWYqf.cjs");
-const require_drizzle = require("./drizzle-DiReZf6d.cjs");
+const require_drizzle = require("./drizzle-bfjVzYR6.cjs");
 let drizzle_orm = require("drizzle-orm");
-let drizzle_orm_pg_core = require("drizzle-orm/pg-core");
 //#region ../sdk/src/drizzle.ts
-function buildColumnsMeta(table) {
-	const columns = (0, drizzle_orm.getTableColumns)(table);
-	const fkByColumn = /* @__PURE__ */ new Map();
-	try {
-		for (const fk of (0, drizzle_orm_pg_core.getTableConfig)(table).foreignKeys) {
-			const ref = fk.reference();
-			const foreignTable = (0, drizzle_orm.getTableName)(ref.foreignTable);
-			ref.columns.forEach((col, i) => {
-				const foreignCol = ref.foreignColumns[i];
-				if (foreignCol) fkByColumn.set(col.name, {
-					table: foreignTable,
-					column: foreignCol.name
-				});
-			});
-		}
-	} catch {}
-	return Object.values(columns).map((col) => {
-		const references = fkByColumn.get(col.name);
-		let type;
-		try {
-			type = col.getSQLType();
-		} catch {
-			type = void 0;
-		}
-		return {
-			name: col.name,
-			type,
-			nullable: !col.notNull,
-			isPrimaryKey: Boolean(col.primary),
-			isForeignKey: references !== void 0,
-			...references ? { references } : {}
-		};
-	});
-}
 function inferIdField(table) {
 	const columns = (0, drizzle_orm.getTableColumns)(table);
 	const primaryKeys = Object.entries(columns).filter(([, column]) => column.primary);
@@ -75,12 +40,14 @@ function fromDrizzle(db, table, opts) {
 		idField: idColumnName,
 		fetchPage: ({ since, limit }) => drizzleDb.select(projection).from(table).where(since ? drizzle_orm.sql`(${cursorColumn}, ${idColumn}) > (${since.time}, ${since.id})` : void 0).orderBy((0, drizzle_orm.asc)(cursorColumn), (0, drizzle_orm.asc)(idColumn)).limit(limit)
 	};
+	const uniqueConstraints = require_drizzle.buildUniqueConstraints(table);
 	const meta = {
 		columnKeys: Object.keys(columns),
 		cursorField: opts.cursorField,
 		idField,
 		tableName: (0, drizzle_orm.getTableName)(table),
-		columnsMeta: buildColumnsMeta(table)
+		columnsMeta: require_drizzle.buildColumnsMeta(table),
+		...uniqueConstraints === void 0 ? {} : { uniqueConstraints }
 	};
 	Object.defineProperty(source, require_drizzle_meta.DRIZZLE_META, {
 		value: meta,
@@ -108,6 +75,7 @@ function drizzleIntrospector(db) {
 	};
 }
 //#endregion
+exports.buildUniqueConstraints = require_drizzle.buildUniqueConstraints;
 exports.discoverFromDrizzle = require_drizzle.discoverFromDrizzle;
 exports.drizzleIntrospector = drizzleIntrospector;
 exports.fromDrizzle = fromDrizzle;

package/drizzle.d.cts

@@ -1,5 +1,5 @@
-import { t as discoverFromDrizzle } from "./drizzle-DmeKSqeF.cjs";
-import { m as SyncSource, t as NamespaceIntrospector } from "./namespace-probe-DRzOtaRT.cjs";
+import { n as buildUniqueConstraints, r as discoverFromDrizzle } from "./drizzle-BhN5M9zt.cjs";
+import { m as SyncSource, t as NamespaceIntrospector } from "./namespace-probe-BSH_p9TK.cjs";
 import { Table } from "drizzle-orm";
 //#region ../sdk/src/drizzle.d.ts
 interface DrizzleDb {
@@ -25,4 +25,4 @@ declare function fromDrizzle(db: DrizzleDb, table: Table, opts: {
  */
 declare function drizzleIntrospector(db: unknown): NamespaceIntrospector;
 //#endregion
-export { discoverFromDrizzle, drizzleIntrospector, fromDrizzle };
+export { buildUniqueConstraints, discoverFromDrizzle, drizzleIntrospector, fromDrizzle };

package/drizzle.d.mts

@@ -1,5 +1,5 @@
-import { t as discoverFromDrizzle } from "./drizzle-CFOr9dU9.mjs";
-import { m as SyncSource, t as NamespaceIntrospector } from "./namespace-probe-B4WE45TH.mjs";
+import { n as buildUniqueConstraints, r as discoverFromDrizzle } from "./drizzle-kBULBAOa.mjs";
+import { m as SyncSource, t as NamespaceIntrospector } from "./namespace-probe-Dsp5uNkS.mjs";
 import { Table } from "drizzle-orm";
 //#region ../sdk/src/drizzle.d.ts
 interface DrizzleDb {
@@ -25,4 +25,4 @@ declare function fromDrizzle(db: DrizzleDb, table: Table, opts: {
  */
 declare function drizzleIntrospector(db: unknown): NamespaceIntrospector;
 //#endregion
-export { discoverFromDrizzle, drizzleIntrospector, fromDrizzle };
+export { buildUniqueConstraints, discoverFromDrizzle, drizzleIntrospector, fromDrizzle };

package/drizzle.mjs

@@ -1,42 +1,7 @@
 import { t as DRIZZLE_META } from "./drizzle-meta-D-5k3n0i.mjs";
-import { t as discoverFromDrizzle } from "./drizzle-B89tLo4T.mjs";
+import { n as buildUniqueConstraints, r as discoverFromDrizzle, t as buildColumnsMeta } from "./drizzle-3kvhkwO7.mjs";
 import { asc, getTableColumns, getTableName, sql } from "drizzle-orm";
-import { getTableConfig } from "drizzle-orm/pg-core";
 //#region ../sdk/src/drizzle.ts
-function buildColumnsMeta(table) {
-	const columns = getTableColumns(table);
-	const fkByColumn = /* @__PURE__ */ new Map();
-	try {
-		for (const fk of getTableConfig(table).foreignKeys) {
-			const ref = fk.reference();
-			const foreignTable = getTableName(ref.foreignTable);
-			ref.columns.forEach((col, i) => {
-				const foreignCol = ref.foreignColumns[i];
-				if (foreignCol) fkByColumn.set(col.name, {
-					table: foreignTable,
-					column: foreignCol.name
-				});
-			});
-		}
-	} catch {}
-	return Object.values(columns).map((col) => {
-		const references = fkByColumn.get(col.name);
-		let type;
-		try {
-			type = col.getSQLType();
-		} catch {
-			type = void 0;
-		}
-		return {
-			name: col.name,
-			type,
-			nullable: !col.notNull,
-			isPrimaryKey: Boolean(col.primary),
-			isForeignKey: references !== void 0,
-			...references ? { references } : {}
-		};
-	});
-}
 function inferIdField(table) {
 	const columns = getTableColumns(table);
 	const primaryKeys = Object.entries(columns).filter(([, column]) => column.primary);
@@ -74,12 +39,14 @@ function fromDrizzle(db, table, opts) {
 		idField: idColumnName,
 		fetchPage: ({ since, limit }) => drizzleDb.select(projection).from(table).where(since ? sql`(${cursorColumn}, ${idColumn}) > (${since.time}, ${since.id})` : void 0).orderBy(asc(cursorColumn), asc(idColumn)).limit(limit)
 	};
+	const uniqueConstraints = buildUniqueConstraints(table);
 	const meta = {
 		columnKeys: Object.keys(columns),
 		cursorField: opts.cursorField,
 		idField,
 		tableName: getTableName(table),
-		columnsMeta: buildColumnsMeta(table)
+		columnsMeta: buildColumnsMeta(table),
+		...uniqueConstraints === void 0 ? {} : { uniqueConstraints }
 	};
 	Object.defineProperty(source, DRIZZLE_META, {
 		value: meta,
@@ -107,4 +74,4 @@ function drizzleIntrospector(db) {
 	};
 }
 //#endregion
-export { discoverFromDrizzle, drizzleIntrospector, fromDrizzle };
+export { buildUniqueConstraints, discoverFromDrizzle, drizzleIntrospector, fromDrizzle };

package/{entity-config-DoUCXtq5.d.cts → entity-config-C4Yf_fPj.d.cts}

@@ -2312,6 +2312,53 @@ declare const entitySchema: ZodObject<{
     }, $strict>]>;
   }, $strict>>>;
   targetObjectTypeId: ZodOptional<ZodString>;
+  projection: ZodOptional<ZodObject<{
+    version: ZodLiteral<1>;
+    kind: ZodLiteral<"projection">;
+    entityKey: ZodString;
+    baseTable: ZodString;
+    joins: ZodArray<ZodObject<{
+      key: ZodString;
+      table: ZodString;
+      type: ZodEnum<{
+        inner: "inner";
+        left: "left";
+      }>;
+      on: ZodArray<ZodObject<{
+        left: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+        op: ZodLiteral<"eq">;
+        right: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>>;
+    }, $strict>>;
+    fieldBindings: ZodRecord<ZodString, ZodObject<{
+      from: ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>;
+    }, $strict>>;
+    identity: ZodUnion<readonly [ZodObject<{
+      kind: ZodLiteral<"base_pk">;
+      column: ZodOptional<ZodString>;
+    }, $strict>, ZodObject<{
+      kind: ZodLiteral<"column">;
+      from: ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>;
+    }, $strict>, ZodObject<{
+      kind: ZodLiteral<"composite">;
+      parts: ZodArray<ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>>;
+    }, $strict>]>;
+  }, $strict>>;
 }, $strict>;
 type ClivlyEntityConfig = output<typeof entitySchema>;
 declare const entitiesConfigSchema: ZodObject<{
@@ -2360,6 +2407,53 @@ declare const entitiesConfigSchema: ZodObject<{
       }, $strict>]>;
     }, $strict>>>;
     targetObjectTypeId: ZodOptional<ZodString>;
+    projection: ZodOptional<ZodObject<{
+      version: ZodLiteral<1>;
+      kind: ZodLiteral<"projection">;
+      entityKey: ZodString;
+      baseTable: ZodString;
+      joins: ZodArray<ZodObject<{
+        key: ZodString;
+        table: ZodString;
+        type: ZodEnum<{
+          inner: "inner";
+          left: "left";
+        }>;
+        on: ZodArray<ZodObject<{
+          left: ZodObject<{
+            table: ZodString;
+            column: ZodString;
+          }, $strict>;
+          op: ZodLiteral<"eq">;
+          right: ZodObject<{
+            table: ZodString;
+            column: ZodString;
+          }, $strict>;
+        }, $strict>>;
+      }, $strict>>;
+      fieldBindings: ZodRecord<ZodString, ZodObject<{
+        from: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>>;
+      identity: ZodUnion<readonly [ZodObject<{
+        kind: ZodLiteral<"base_pk">;
+        column: ZodOptional<ZodString>;
+      }, $strict>, ZodObject<{
+        kind: ZodLiteral<"column">;
+        from: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>, ZodObject<{
+        kind: ZodLiteral<"composite">;
+        parts: ZodArray<ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>>;
+      }, $strict>]>;
+    }, $strict>>;
   }, $strict>>;
 }, $strict>;
 type ClivlyEntitiesConfig = output<typeof entitiesConfigSchema>;
@@ -2384,14 +2478,39 @@ declare function defineClivlyConfig(config: ClivlyEntitiesConfig, options?: {
   strict?: boolean;
   onWarn?: (message: string) => void;
 }): ClivlyEntitiesConfig;
+/**
+ * Per-column metadata a host reports for a discovered table. Structurally
+ * identical to the SDK's `DiscoveredColumn` and to `entity-heuristics.ts`'s
+ * (currently separate) `DiscoveredColumnMeta` — a later task converges that
+ * module onto this one. Every field is optional: a v1 host reports column
+ * names only.
+ */
+interface DiscoveredColumnMeta {
+  isForeignKey?: boolean;
+  isPrimaryKey?: boolean;
+  name: string;
+  nullable?: boolean;
+  references?: {
+    table: string;
+    column: string;
+  };
+  type?: string;
+}
 /**
  * A host table the SDK reported for discovery. Structurally identical to the
  * SDK's `DiscoveredTable`; duplicated here to keep `@clivly/core` free of an
  * SDK dependency (core is the base contract SDK builds on).
+ *
+ * `columns` is the stable v1 contract. `columnsMeta` and `uniqueConstraints`
+ * are the enrichment projection mappings require — absent on v1 hosts, which
+ * is why projection validation fails closed rather than assuming "no keys".
  */
 interface DiscoveredSchemaTable {
   columns: string[];
+  columnsMeta?: DiscoveredColumnMeta[];
   name: string;
+  /** Every unique key as DB column names; PKs included. Absent = unknown. */
+  uniqueConstraints?: string[][];
 }
 interface ConfigValidationError {
   message: string;
@@ -2413,4 +2532,4 @@ interface ConfigValidationResult {
  */
 declare function validateEntitiesConfig(config: ClivlyEntitiesConfig, schema: DiscoveredSchemaTable[]): ConfigValidationResult;
 //#endregion
-export { validateEntitiesConfig as C, relationshipsSchema as S, RelationshipsMap as _, ClivlyEntitiesConfig as a, filterSchema as b, ConfigValidationResult as c, FilterExpr as d, FilterValue as f, RelationshipVia as g, RelationshipSpec as h, ClivlyConfigError as i, CrmConcept as l, MaterializingConcept as m, CRM_CONCEPTS as n, ClivlyEntityConfig as o, MATERIALIZING_CONCEPTS as p, CUSTOM_CONCEPT as r, ConfigValidationError as s, CANONICAL_FIELDS as t, DiscoveredSchemaTable as u, defineClivlyConfig as v, relationshipSchema as x, entitiesConfigSchema as y };
+export { ZodRecord as A, relationshipsSchema as C, ZodLiteral as D, ZodEnum as E, ZodUnion as M, output as N, ZodObject as O, $strict as P, relationshipSchema as S, ZodArray as T, RelationshipVia as _, ClivlyEntitiesConfig as a, entitiesConfigSchema as b, ConfigValidationResult as c, DiscoveredSchemaTable as d, FilterExpr as f, RelationshipSpec as g, MaterializingConcept as h, ClivlyConfigError as i, ZodString as j, ZodOptional as k, CrmConcept as l, MATERIALIZING_CONCEPTS as m, CRM_CONCEPTS as n, ClivlyEntityConfig as o, FilterValue as p, CUSTOM_CONCEPT as r, ConfigValidationError as s, CANONICAL_FIELDS as t, DiscoveredColumnMeta as u, RelationshipsMap as v, validateEntitiesConfig as w, filterSchema as x, defineClivlyConfig as y };

package/{entity-config-DoUCXtq5.d.mts → entity-config-C4Yf_fPj.d.mts}

@@ -2312,6 +2312,53 @@ declare const entitySchema: ZodObject<{
     }, $strict>]>;
   }, $strict>>>;
   targetObjectTypeId: ZodOptional<ZodString>;
+  projection: ZodOptional<ZodObject<{
+    version: ZodLiteral<1>;
+    kind: ZodLiteral<"projection">;
+    entityKey: ZodString;
+    baseTable: ZodString;
+    joins: ZodArray<ZodObject<{
+      key: ZodString;
+      table: ZodString;
+      type: ZodEnum<{
+        inner: "inner";
+        left: "left";
+      }>;
+      on: ZodArray<ZodObject<{
+        left: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+        op: ZodLiteral<"eq">;
+        right: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>>;
+    }, $strict>>;
+    fieldBindings: ZodRecord<ZodString, ZodObject<{
+      from: ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>;
+    }, $strict>>;
+    identity: ZodUnion<readonly [ZodObject<{
+      kind: ZodLiteral<"base_pk">;
+      column: ZodOptional<ZodString>;
+    }, $strict>, ZodObject<{
+      kind: ZodLiteral<"column">;
+      from: ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>;
+    }, $strict>, ZodObject<{
+      kind: ZodLiteral<"composite">;
+      parts: ZodArray<ZodObject<{
+        table: ZodString;
+        column: ZodString;
+      }, $strict>>;
+    }, $strict>]>;
+  }, $strict>>;
 }, $strict>;
 type ClivlyEntityConfig = output<typeof entitySchema>;
 declare const entitiesConfigSchema: ZodObject<{
@@ -2360,6 +2407,53 @@ declare const entitiesConfigSchema: ZodObject<{
       }, $strict>]>;
     }, $strict>>>;
     targetObjectTypeId: ZodOptional<ZodString>;
+    projection: ZodOptional<ZodObject<{
+      version: ZodLiteral<1>;
+      kind: ZodLiteral<"projection">;
+      entityKey: ZodString;
+      baseTable: ZodString;
+      joins: ZodArray<ZodObject<{
+        key: ZodString;
+        table: ZodString;
+        type: ZodEnum<{
+          inner: "inner";
+          left: "left";
+        }>;
+        on: ZodArray<ZodObject<{
+          left: ZodObject<{
+            table: ZodString;
+            column: ZodString;
+          }, $strict>;
+          op: ZodLiteral<"eq">;
+          right: ZodObject<{
+            table: ZodString;
+            column: ZodString;
+          }, $strict>;
+        }, $strict>>;
+      }, $strict>>;
+      fieldBindings: ZodRecord<ZodString, ZodObject<{
+        from: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>>;
+      identity: ZodUnion<readonly [ZodObject<{
+        kind: ZodLiteral<"base_pk">;
+        column: ZodOptional<ZodString>;
+      }, $strict>, ZodObject<{
+        kind: ZodLiteral<"column">;
+        from: ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>;
+      }, $strict>, ZodObject<{
+        kind: ZodLiteral<"composite">;
+        parts: ZodArray<ZodObject<{
+          table: ZodString;
+          column: ZodString;
+        }, $strict>>;
+      }, $strict>]>;
+    }, $strict>>;
   }, $strict>>;
 }, $strict>;
 type ClivlyEntitiesConfig = output<typeof entitiesConfigSchema>;
@@ -2384,14 +2478,39 @@ declare function defineClivlyConfig(config: ClivlyEntitiesConfig, options?: {
   strict?: boolean;
   onWarn?: (message: string) => void;
 }): ClivlyEntitiesConfig;
+/**
+ * Per-column metadata a host reports for a discovered table. Structurally
+ * identical to the SDK's `DiscoveredColumn` and to `entity-heuristics.ts`'s
+ * (currently separate) `DiscoveredColumnMeta` — a later task converges that
+ * module onto this one. Every field is optional: a v1 host reports column
+ * names only.
+ */
+interface DiscoveredColumnMeta {
+  isForeignKey?: boolean;
+  isPrimaryKey?: boolean;
+  name: string;
+  nullable?: boolean;
+  references?: {
+    table: string;
+    column: string;
+  };
+  type?: string;
+}
 /**
  * A host table the SDK reported for discovery. Structurally identical to the
  * SDK's `DiscoveredTable`; duplicated here to keep `@clivly/core` free of an
  * SDK dependency (core is the base contract SDK builds on).
+ *
+ * `columns` is the stable v1 contract. `columnsMeta` and `uniqueConstraints`
+ * are the enrichment projection mappings require — absent on v1 hosts, which
+ * is why projection validation fails closed rather than assuming "no keys".
  */
 interface DiscoveredSchemaTable {
   columns: string[];
+  columnsMeta?: DiscoveredColumnMeta[];
   name: string;
+  /** Every unique key as DB column names; PKs included. Absent = unknown. */
+  uniqueConstraints?: string[][];
 }
 interface ConfigValidationError {
   message: string;
@@ -2413,4 +2532,4 @@ interface ConfigValidationResult {
  */
 declare function validateEntitiesConfig(config: ClivlyEntitiesConfig, schema: DiscoveredSchemaTable[]): ConfigValidationResult;
 //#endregion
-export { validateEntitiesConfig as C, relationshipsSchema as S, RelationshipsMap as _, ClivlyEntitiesConfig as a, filterSchema as b, ConfigValidationResult as c, FilterExpr as d, FilterValue as f, RelationshipVia as g, RelationshipSpec as h, ClivlyConfigError as i, CrmConcept as l, MaterializingConcept as m, CRM_CONCEPTS as n, ClivlyEntityConfig as o, MATERIALIZING_CONCEPTS as p, CUSTOM_CONCEPT as r, ConfigValidationError as s, CANONICAL_FIELDS as t, DiscoveredSchemaTable as u, defineClivlyConfig as v, relationshipSchema as x, entitiesConfigSchema as y };
+export { ZodRecord as A, relationshipsSchema as C, ZodLiteral as D, ZodEnum as E, ZodUnion as M, output as N, ZodObject as O, $strict as P, relationshipSchema as S, ZodArray as T, RelationshipVia as _, ClivlyEntitiesConfig as a, entitiesConfigSchema as b, ConfigValidationResult as c, DiscoveredSchemaTable as d, FilterExpr as f, RelationshipSpec as g, MaterializingConcept as h, ClivlyConfigError as i, ZodString as j, ZodOptional as k, CrmConcept as l, MATERIALIZING_CONCEPTS as m, CRM_CONCEPTS as n, ClivlyEntityConfig as o, FilterValue as p, CUSTOM_CONCEPT as r, ConfigValidationError as s, CANONICAL_FIELDS as t, DiscoveredColumnMeta as u, RelationshipsMap as v, validateEntitiesConfig as w, filterSchema as x, defineClivlyConfig as y };