diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0253314..6fe8f1e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 - Type for special error listener `srv.on('error')`
 
+### Changed
+
+- `source`, `column_expr`, and `predicate` have been converted to partial intersection types. This offers all possible optional properties. You will have to make sure to check their presence when accessing them
+
 ### Fixed
 
 - `srv.send` overload to also allow optional headers
@@ -17,13 +21,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `cds.builtin.types` got a more accurate type
 - The `LinkedEntity.drafts` property is now optional.  At runtime, it's only set for drafted entities.
 - `cds.model` is marked as modifiable (for tests only!)
+- `SELECT.from` got its `ref` property back
 
 
 ## Version 0.1.0 - 2023-12-13
 
 ### Changed
 
-- Rework of the export structure of the main `cds` facade object, so that e.g. `cds.Request` and `cds.User` work again.
+- Rework of the export structure of the main `cds` facade object, so that e.g. `cds.Request` and `cds.User` work again
 
 ### Fixed
 
diff --git a/apis/cqn.d.ts b/apis/cqn.d.ts
index 539d355f..35bec7e5 100644
--- a/apis/cqn.d.ts
+++ b/apis/cqn.d.ts
@@ -1,4 +1,5 @@
 import { entity } from './csn' // cyclic dependency
+import { UnionToIntersection, UnionsToIntersections } from './internal/inference'
 
 // FIXME: a union type would be more appropriate here
 export type Query = Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>
@@ -66,9 +67,9 @@ type data = Record<string, any>
 type name = string
 
 /** @private */
-type source = (ref | SELECT) & { as?: name, join?: name, on?: xpr }
-export type column_expr = expr & { as?: name, cast?: any, expand?: column_expr[], inline?: column_expr[] }
-export type predicate = _xpr
+type source = UnionToIntersection<ref | SELECT> & { as?: name, join?: name, on?: xpr }
+export type column_expr = UnionToIntersection<expr> & { as?: name, cast?: any, expand?: column_expr[], inline?: column_expr[] }
+export type predicate = UnionsToIntersections<_xpr>
 
 /** @private */
 type ordering_term = expr & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
diff --git a/apis/internal/inference.d.ts b/apis/internal/inference.d.ts
index 4eb65f06..db685098 100644
--- a/apis/internal/inference.d.ts
+++ b/apis/internal/inference.d.ts
@@ -30,3 +30,37 @@ export type Unwrap<T> = T extends ArrayConstructable
   : T extends Array<infer U>
     ? U
     : T
+
+
+/*
+ * the following three types are used to convert union types to intersection types.
+ * We need these as our types currently lack generics in places where we would need them to clearly decide
+ * on a subtype in the case of a union type. This leads to the following problem:
+ *
+ * ```ts
+ * type A = { a: number }
+ * type B = { b: string }
+ * type Foo = A | B
+ * function f(): Foo { ... }
+ * const x = f()
+ * x.a  // error, could also be B
+ * ```
+ *
+ * While we should have:
+ *
+ * ```ts
+ * function f<T extends Foo>(): T { ... }
+ * const x = f<A>()
+ * x.a
+ * ```ts
+ *
+ * Since we don't do that yet, we opt for intersection types instead.
+ * By also wrapping it in Partial, we at least force the user to check for the presence of any
+ * attribute they try to access.
+ *
+ * Places where these types are used are subject to a rework!
+ * the idea behind the conversion can be found in this excellent writeup: https://fettblog.eu/typescript-union-to-intersection/
+ */
+export type Scalarise<A> = A extends Array<infer N> ? N : A
+export type UnionToIntersection<U> = Partial<(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never>
+export type UnionsToIntersections<U> = Array<UnionToIntersection<Scalarise<U>>>
diff --git a/test/typescript/apis/project/cds-ql.ts b/test/typescript/apis/project/cds-ql.ts
index 252d740d..ff88940d 100644
--- a/test/typescript/apis/project/cds-ql.ts
+++ b/test/typescript/apis/project/cds-ql.ts
@@ -11,6 +11,13 @@ sel.from(Foos)
 sel.columns("x") // x was suggested by code completion
 sel.SELECT.columns?.filter(e => !e) // check if this is array
 
+// ensure ql returns a proper CQN
+const s = SELECT.from(Foos).columns('ID').where('ID =', 42)
+s.SELECT.from.ref
+s.SELECT.columns?.[0].ref
+s.SELECT.where?.[0].ref
+s.SELECT.where?.[2].val
+
 INSERT.into(Foos).columns("x") // x was suggested by code completion
 let ins: INSERT<Foo>
 ins = INSERT.into(Foos, {})