clivly 0.8.0 → 0.9.1

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

@@ -2120,6 +2120,126 @@ interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadon
 }
 declare const ZodReadonly: $constructor<ZodReadonly>;
 //#endregion
+//#region ../core/src/projection.d.ts
+/**
+ * Projection-backed custom mappings — one custom object derived from a base
+ * table plus explicit joins.
+ *
+ * A projection is deliberately narrow: equality joins only, direct column
+ * bindings only, no expressions and no aggregation. Everything a user can
+ * express here compiles to a single read-only view whose `id` column is
+ * provably unique per row, which is what lets the sync engine consume it
+ * unchanged.
+ *
+ * Refs address tables symbolically: `"base"` for the base table, or a join's
+ * `key`. Raw table names are never accepted in a ref, so a projection can
+ * never reach a table it did not declare.
+ */
+/** The reserved ref name for the projection's base table. */
+declare const BASE_REF = "base";
+declare const projectionRefSchema: ZodObject<{
+  table: ZodString;
+  column: ZodString;
+}, $strict>;
+type ProjectionRef = output<typeof projectionRefSchema>;
+declare const projectionJoinSchema: 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>;
+type ProjectionJoin = output<typeof projectionJoinSchema>;
+declare const projectionFieldBindingSchema: ZodObject<{
+  from: ZodObject<{
+    table: ZodString;
+    column: ZodString;
+  }, $strict>;
+}, $strict>;
+type ProjectionFieldBinding = output<typeof projectionFieldBindingSchema>;
+declare const projectionIdentitySchema: 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>]>;
+type ProjectionIdentity = output<typeof projectionIdentitySchema>;
+declare const projectionSchema: 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>;
+type ProjectionMapping = output<typeof projectionSchema>;
+/**
+ * Every column ref an identity depends on. `basePkColumn` is the base table's
+ * discovered PK, used only when a `base_pk` identity omits an explicit column.
+ */
+declare function identityRefs(identity: ProjectionIdentity, basePkColumn: string): ProjectionRef[];
+//#endregion
 //#region ../core/src/entity-config.d.ts
 /**
  * Entity Config v2 — the declarative contract that turns Clivly's "schema-aware"
@@ -2312,6 +2432,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,9 +2527,71 @@ 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>;
+/**
+ * What an author may hand to `defineClivlyConfig`. Identical to
+ * `ClivlyEntityConfig` except that a projection entity may omit `fields` —
+ * it is derived from `projection.fieldBindings`. Without a projection `fields`
+ * stays required, so the looser input never weakens the ordinary case.
+ */
+type ClivlyEntityConfigInput = (ClivlyEntityConfig & {
+  projection?: undefined;
+}) | (Omit<ClivlyEntityConfig, "fields"> & {
+  fields?: Record<string, string>;
+  projection: ProjectionMapping;
+});
+type ClivlyEntitiesConfigInput = Omit<ClivlyEntitiesConfig, "entities"> & {
+  entities: Record<string, ClivlyEntityConfigInput>;
+};
 /** Thrown by `defineClivlyConfig({ strict: true })` on non-canonical field keys. */
 declare class ClivlyConfigError extends Error {
   readonly issues: ConfigValidationError[];
@@ -2380,18 +2609,50 @@ declare class ClivlyConfigError extends Error {
  * a `ClivlyConfigError` instead. Does NOT validate against the host schema — that
  * needs the discovered schema; see `validateEntitiesConfig`.
  */
-declare function defineClivlyConfig(config: ClivlyEntitiesConfig, options?: {
+/**
+ * The `fields` entry a projection binding implies, qualified as `ref.column`.
+ * Qualified rather than bare: two bindings can pull the same column name from
+ * different tables (`cl.full_name` and `adv.full_name`), which a bare column
+ * name cannot tell apart.
+ */
+declare function projectionFields(projection: ProjectionMapping): Record<string, string>;
+declare function defineClivlyConfig(config: ClivlyEntitiesConfigInput, 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 +2674,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 { ProjectionIdentity as A, filterSchema as C, validateEntitiesConfig as D, relationshipsSchema as E, projectionSchema as F, ProjectionMapping as M, ProjectionRef as N, BASE_REF as O, identityRefs as P, entitiesConfigSchema as S, relationshipSchema as T, MaterializingConcept as _, ClivlyEntitiesConfig as a, RelationshipsMap as b, ClivlyEntityConfigInput as c, CrmConcept as d, DiscoveredColumnMeta as f, MATERIALIZING_CONCEPTS as g, FilterValue as h, ClivlyConfigError as i, ProjectionJoin as j, ProjectionFieldBinding as k, ConfigValidationError as l, FilterExpr as m, CRM_CONCEPTS as n, ClivlyEntitiesConfigInput as o, DiscoveredSchemaTable as p, CUSTOM_CONCEPT as r, ClivlyEntityConfig as s, CANONICAL_FIELDS as t, ConfigValidationResult as u, RelationshipSpec as v, projectionFields as w, defineClivlyConfig as x, RelationshipVia as y };

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

@@ -2120,6 +2120,126 @@ interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadon
 }
 declare const ZodReadonly: $constructor<ZodReadonly>;
 //#endregion
+//#region ../core/src/projection.d.ts
+/**
+ * Projection-backed custom mappings — one custom object derived from a base
+ * table plus explicit joins.
+ *
+ * A projection is deliberately narrow: equality joins only, direct column
+ * bindings only, no expressions and no aggregation. Everything a user can
+ * express here compiles to a single read-only view whose `id` column is
+ * provably unique per row, which is what lets the sync engine consume it
+ * unchanged.
+ *
+ * Refs address tables symbolically: `"base"` for the base table, or a join's
+ * `key`. Raw table names are never accepted in a ref, so a projection can
+ * never reach a table it did not declare.
+ */
+/** The reserved ref name for the projection's base table. */
+declare const BASE_REF = "base";
+declare const projectionRefSchema: ZodObject<{
+  table: ZodString;
+  column: ZodString;
+}, $strict>;
+type ProjectionRef = output<typeof projectionRefSchema>;
+declare const projectionJoinSchema: 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>;
+type ProjectionJoin = output<typeof projectionJoinSchema>;
+declare const projectionFieldBindingSchema: ZodObject<{
+  from: ZodObject<{
+    table: ZodString;
+    column: ZodString;
+  }, $strict>;
+}, $strict>;
+type ProjectionFieldBinding = output<typeof projectionFieldBindingSchema>;
+declare const projectionIdentitySchema: 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>]>;
+type ProjectionIdentity = output<typeof projectionIdentitySchema>;
+declare const projectionSchema: 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>;
+type ProjectionMapping = output<typeof projectionSchema>;
+/**
+ * Every column ref an identity depends on. `basePkColumn` is the base table's
+ * discovered PK, used only when a `base_pk` identity omits an explicit column.
+ */
+declare function identityRefs(identity: ProjectionIdentity, basePkColumn: string): ProjectionRef[];
+//#endregion
 //#region ../core/src/entity-config.d.ts
 /**
  * Entity Config v2 — the declarative contract that turns Clivly's "schema-aware"
@@ -2312,6 +2432,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,9 +2527,71 @@ 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>;
+/**
+ * What an author may hand to `defineClivlyConfig`. Identical to
+ * `ClivlyEntityConfig` except that a projection entity may omit `fields` —
+ * it is derived from `projection.fieldBindings`. Without a projection `fields`
+ * stays required, so the looser input never weakens the ordinary case.
+ */
+type ClivlyEntityConfigInput = (ClivlyEntityConfig & {
+  projection?: undefined;
+}) | (Omit<ClivlyEntityConfig, "fields"> & {
+  fields?: Record<string, string>;
+  projection: ProjectionMapping;
+});
+type ClivlyEntitiesConfigInput = Omit<ClivlyEntitiesConfig, "entities"> & {
+  entities: Record<string, ClivlyEntityConfigInput>;
+};
 /** Thrown by `defineClivlyConfig({ strict: true })` on non-canonical field keys. */
 declare class ClivlyConfigError extends Error {
   readonly issues: ConfigValidationError[];
@@ -2380,18 +2609,50 @@ declare class ClivlyConfigError extends Error {
  * a `ClivlyConfigError` instead. Does NOT validate against the host schema — that
  * needs the discovered schema; see `validateEntitiesConfig`.
  */
-declare function defineClivlyConfig(config: ClivlyEntitiesConfig, options?: {
+/**
+ * The `fields` entry a projection binding implies, qualified as `ref.column`.
+ * Qualified rather than bare: two bindings can pull the same column name from
+ * different tables (`cl.full_name` and `adv.full_name`), which a bare column
+ * name cannot tell apart.
+ */
+declare function projectionFields(projection: ProjectionMapping): Record<string, string>;
+declare function defineClivlyConfig(config: ClivlyEntitiesConfigInput, 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 +2674,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 { ProjectionIdentity as A, filterSchema as C, validateEntitiesConfig as D, relationshipsSchema as E, projectionSchema as F, ProjectionMapping as M, ProjectionRef as N, BASE_REF as O, identityRefs as P, entitiesConfigSchema as S, relationshipSchema as T, MaterializingConcept as _, ClivlyEntitiesConfig as a, RelationshipsMap as b, ClivlyEntityConfigInput as c, CrmConcept as d, DiscoveredColumnMeta as f, MATERIALIZING_CONCEPTS as g, FilterValue as h, ClivlyConfigError as i, ProjectionJoin as j, ProjectionFieldBinding as k, ConfigValidationError as l, FilterExpr as m, CRM_CONCEPTS as n, ClivlyEntitiesConfigInput as o, DiscoveredSchemaTable as p, CUSTOM_CONCEPT as r, ClivlyEntityConfig as s, CANONICAL_FIELDS as t, ConfigValidationResult as u, RelationshipSpec as v, projectionFields as w, defineClivlyConfig as x, RelationshipVia as y };