@cap-js/cds-types 0.6.5 → 0.8.0

package/dist/cds-types.d.ts

@@ -1,5 +1,5 @@
 declare module '@sap/cds' {
-
+
 
 export type __any_ = classes.any_
 
@@ -70,6 +70,12 @@ export interface ActionEventHandler<P, R> {
     (req: Omit<Request_2, 'data'> & { data: P }, next: Function): Promise<R> | R
 }
 
+interface And {
+    and: TaggedTemplateQueryPart<this>
+    & ((predicate: object) => this)
+    & ((...expr: any[]) => this)
+}
+
 const any: typeof any_;
 
 interface any_ extends csn.any_ {}
@@ -87,6 +93,13 @@ interface any__2 {
     kind?: kinds
 }
 
+/**
+ * The {@link https://expressjs.com/en/4x/api.html#app| express.js application} constructed by the server implementation.
+ *
+ * @see [capire](https://cap.cloud.sap/docs/node.js/cds-server#cds-app)
+ */
+export const app: import('express').Application;
+
 export class ApplicationService extends Service {}
 
 export class array extends type<'type' | 'elements'> { }
@@ -95,20 +108,6 @@ interface ArrayConstructable<T = any> {
     new(...args: any[]): T[]
 }
 
-/**
- * A subset of array-like methods, but not `ArrayLike`, as it does not expose `.length`.
- * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
- * @internal
- * @since cds 7.9
- */
-type _ArrayLike<T> = Iterable<T> & {
-    forEach: (handler: (element: T) => any) => void,
-    filter: (predicate: (element: T) => boolean) => Array<T>,
-    map: <R>(converter: (element: T) => R) => Array<R>,
-    some: (predicate: (element: T) => boolean) => boolean,
-    find: (predicate: (element: T) => boolean) => T | undefined,
-}
-
 class aspect<K extends kinds = 'aspect'> extends type<K> implements WithElements {
     elements: Definitions<type<'type'>>
 }
@@ -130,7 +129,6 @@ export class Association extends type {
 }
 
 interface Association_2 extends type_2 {
-    type: 'cds.Association' | 'cds.Composition'
     target: FQN
 
     /**
@@ -154,17 +152,17 @@ type Awaitable<T, I> = T & Promise<I>
 class Axios {
 
     get axios (): import('axios').AxiosInstance
-    get: import('axios').AxiosInstance['get'];
+    get: import('axios').AxiosInstance['get'] & TaggedTemplateRequest
 
-    put: import('axios').AxiosInstance['put']
+    put: import('axios').AxiosInstance['put'] & TaggedTemplateRequest
 
-    post: import('axios').AxiosInstance['post']
+    post: import('axios').AxiosInstance['post'] & TaggedTemplateRequest
 
-    patch: import('axios').AxiosInstance['patch']
+    patch: import('axios').AxiosInstance['patch'] & TaggedTemplateRequest
 
-    delete: import('axios').AxiosInstance['delete']
+    delete: import('axios').AxiosInstance['delete'] & TaggedTemplateRequest
 
-    options: import('axios').AxiosInstance['options']
+    options: import('axios').AxiosInstance['options'] & TaggedTemplateRequest
 
     get GET (): Axios['get']
 
@@ -197,6 +195,10 @@ export const builtin: {
     types: Record<string, object>, // FIXME: value should be any class part of linked.classes
 };
 
+interface ByKey {
+    byKey (primaryKey?: PK): this
+}
+
 export type CDL = string
 
 namespace cds {
@@ -212,6 +214,7 @@ namespace cds {
         version,
         home,
         root,
+        cli,
         requires,
         extend,
         lazify,
@@ -238,11 +241,13 @@ namespace cds {
         cds_connect_options,
         Middleswares,
         middlewares,
+        app,
         env,
         _TODO,
         get,
         load,
         resolve,
+        minify,
         reflect,
         _flavor,
         _odata_options,
@@ -352,6 +357,8 @@ namespace cds {
         ordering_term,
         expr,
         ref,
+        _segment,
+        _named,
         val,
         xpr,
         _xpr,
@@ -370,7 +377,7 @@ export interface cds_connect_options {
     impl?: string
     service?: string
     kind?: string
-    model?: string
+    model?: string | CSN
     credentials?: object
 }
 
@@ -383,7 +390,9 @@ export interface cds_serve_fluent {
     // (req,res) : void
 }
 
-export type cds_services = { [name: string]: Service }
+export interface cds_services {
+    [name: string]: Service
+}
 
 export type CdsFunction = {
     (...args: any[]): any,
@@ -440,10 +449,34 @@ namespace classes {
     }
 }
 
+/**
+ * The parsed effective `cds` CLI command and arguments.
+ * May be undefined if not started from the `cds` CLI.
+ * @see https://cap.cloud.sap/docs/node.js/cds-facade#cds-cli
+ */
+export const cli: {
+    /** Basic command like `serve` */ command?: CliCommands,
+    /** Positional arguments */       argv?: string[],
+    /** Named arguments */            options?: Record<string, any>,
+} | undefined;
+
+type CliCommands = 'add' | 'build' | 'compile' | 'deploy' | 'import' | 'init' | 'serve' | (string & {})
+
 type Column = { ref: [string], as?: string }
 
 export type column_expr = UnionToIntersection<expr> & { as?: name, cast?: any, expand?: column_expr[], inline?: column_expr[] }
 
+interface Columns<T, This = undefined> {
+    columns:
+    ((...col: KeyOfSingular<T>[]) => This extends undefined ? this : This)
+    & ((col: KeyOfSingular<T>[]) => This extends undefined ? this : This)
+    & ((...col: (string | column_expr)[]) => This extends undefined ? this : This)
+    & ((col: (string | column_expr)[]) => This extends undefined ? this : This)
+    & TaggedTemplateQueryPart<This extends undefined ? this : This>
+}
+
+type ColumnValue = Primitive | Readonly<Primitive[]> | SELECT<any>
+
 /**
  * Provides a set of methods to parse a given model, query or expression.
  * You can also use `cds.compile(csn).to('<output>')` as a fluent variant.
@@ -456,6 +489,7 @@ export const compile: {
     for: {
         odata (model: csn.CSN, o?: _options): csn.CSN,
         sql (model: csn.CSN, o?: _options): csn.CSN,
+        nodejs (model: csn.CSN, o?: _options): linked.LinkedCSN,
     },
     to: {
         parsed: {
@@ -575,8 +609,10 @@ interface Constructable<T = any> {
     new(...args: any[]): T
 }
 
-class ConstructedQuery {
-
+class ConstructedQuery<T> {
+    // branded type to break covariance for the subclasses
+    // that don't make explicit use of the generic. So `UPDATE<Books> !<: UPDATE<number>`
+    private _: T
     then (_resolved: (x: any) => any, _rejected: (e: Error) => any): any
 
 }
@@ -611,6 +647,8 @@ namespace CQN {
         ordering_term,
         expr,
         ref,
+        _segment,
+        _named,
         val,
         xpr,
         _xpr,
@@ -629,9 +667,10 @@ type CREATE_2 = { CREATE: {
     }, }
 export { CREATE_2 as CREATE }
 
-class CREATE_3<T> extends ConstructedQuery {
+class CREATE_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
-    static entity (entity: Target): CREATE_3<any>
+    static entity (entity: EntityDescription): CREATE_3<EntityDescription>
 
     CREATE: CQN.CREATE['CREATE']
 
@@ -743,7 +782,17 @@ export const db: DatabaseService;
  */
 export function debug (name: string): undefined | Log
 
-class Decimal extends Float { }
+class Decimal extends Float { 
+    precision?: number
+    scale?: number
+}
+
+/**
+ * Recursively excludes nullability from all properties of T.
+ */
+type DeepRequired<T> = { 
+    [K in keyof T]: DeepRequired<T[K]>
+} & Exclude<Required<T>, null>
 
 export namespace default_2 {
     export {
@@ -757,6 +806,7 @@ export namespace default_2 {
         version,
         home,
         root,
+        cli,
         requires,
         extend,
         lazify,
@@ -783,11 +833,13 @@ export namespace default_2 {
         cds_connect_options,
         Middleswares,
         middlewares,
+        app,
         env,
         _TODO,
         get,
         load,
         resolve,
+        minify,
         reflect,
         _flavor,
         _odata_options,
@@ -897,6 +949,8 @@ export namespace default_2 {
         ordering_term,
         expr,
         ref,
+        _segment,
+        _named,
         val,
         xpr,
         _xpr,
@@ -928,22 +982,16 @@ type DELETE_2 = { DELETE: {
     }, }
 export { DELETE_2 as DELETE }
 
-class DELETE_3<T> extends ConstructedQuery {
+interface DELETE_3<T> extends Where<T>, And, ByKey {}
 
-    static from:
-    TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
-    & ((entity: Target | ArrayConstructable, primaryKey?: PK) => DELETE_3<any>)
-    & ((subject: ref) => DELETE_3<any>)
+class DELETE_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
-    byKey (primaryKey?: PK): this
-
-    where (predicate: object): this
-
-    where (...expr: any[]): this
-
-    and (predicate: object): this
+    static from:
+    TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<StaticAny>>>
+    & (<T>(entity: EntityDescription | ArrayConstructable, primaryKey?: PK) => DELETE_3<T>)
+    & ((subject: ref) => DELETE_3<_TODO_2>)
 
-    and (...expr: any[]): this
     DELETE: CQN.DELETE['DELETE']
 
 }
@@ -957,9 +1005,10 @@ type DROP_2 = { DROP: {
     }, }
 export { DROP_2 as DROP }
 
-class DROP_3<T> extends ConstructedQuery {
+class DROP_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
-    static entity (entity: Target): DROP_3<any>
+    static entity (entity: EntityDescription): DROP_3<EntityDescription>
 
     DROP: CQN.DROP['DROP']
 
@@ -1010,15 +1059,22 @@ interface entity_2 extends Omit<struct_2, 'elements'> {
     drafts?: entity_2
 }
 
+type EntityDescription = entity | Definition | string
+
 type EntityElements = {
     [name: string]: Element & {
         key?: boolean,
         virtual?: boolean,
         unique?: boolean,
         notNull?: boolean,
+        precision?: number,
+        scale?: number,
+        length?: number,
     },
 }
 
+type Entries<T = any> = {[key:string]: T} | {[key:string]: T}
+
 export type enum_literal = { '#': string }
 
 /**
@@ -1036,6 +1092,7 @@ export const env: {
         folders: string[],
         [key: string]: any,
     },
+    profiles: string[],
     requires: env.Requires,
     folders: {
         app: string,
@@ -1087,23 +1144,50 @@ export namespace env {
             binding?: Binding,
             [key: string]: any,
         },
-        multitenancy: boolean | { kind: string, jobs: {
+        multitenancy?: boolean | { kind: string, jobs: {
                 clusterSize: number,
                 workerSize: number,
                 t0: string,
                 [key: string]: any,
             },},
-        toggles: boolean,
-        extensibility: boolean | {
+        toggles?: boolean,
+        extensibility?: boolean | {
             model: string[],
             tenantCheckInterval: number,
             [key: string]: any,
         },
-        messaging: {
+        messaging?: {
             kind: 'file-based-messaging' | 'redis-messaging' | 'local-messaging' | 'enterprise-messaging' | 'enterprise-messaging-shared' | string,
             format: 'cloudevents' | string,
             [key: string]: any,
         },
+        'cds.xt.SaasProvisioningService'?: {
+            model: string,
+            kind: string,
+            alwaysUpgradeModel?: boolean,
+            [key: string]: any,
+        },
+        'cds.xt.SmsProvisioningService'?: {
+            model: string,
+            kind: string,
+            [key: string]: any,
+        },
+        'cds.xt.ExtensibilityService'?: {
+            model: string,
+            kind?: string,
+            [key: string]: any,
+        },
+        'cds.xt.ModelProviderService'?: {
+            model: string,
+            root: string,
+            kind?: string,
+            [key: string]: any,
+        },
+        'cds.xt.DeploymentService'?: {
+            model: string,
+            kind?: string,
+            [key: string]: any,
+        },
         [key: string]: any,
     }
 
@@ -1140,6 +1224,10 @@ class Event_2 extends EventContext {
 
     headers: any
 
+    before(phase: 'commit', handler: () => void)
+
+    on(phase: 'succeeded' | 'failed' | 'done', handler: () => void)
+
 }
 export { Event_2 as Event }
 
@@ -1164,6 +1252,8 @@ export class EventContext {
 
     features?: { [key: string]: boolean }
 
+    model: LinkedCSN
+
 }
 
 export interface EventHandler {
@@ -1181,6 +1271,15 @@ export type expr = ref | val | xpr | function_call | SELECT_2
 
 export type expr_literal = { '=': string }
 
+type Expression<E extends string | number | bigint | boolean> = `${E}${WS}${Op}${WS}`
+
+type Expressions<L,E> = KVPairs<L, Expression<Exclude<keyof E, symbol>>, ColumnValue> extends true 
+? L 
+// fallback: allow for any string. Important for when user renamed properties
+: KVPairs<L, Expression<string>, ColumnValue> extends true
+? L
+: never
+
 /**
  * Add aspects to a given object, for example:
  *
@@ -1244,6 +1343,40 @@ export type function_call = { func: string, args: { [key: string]: any }[] }
  */
 export function get (files: '*' | filename | filename[], o?: _options): Promise<csn.CSN>
 
+interface GroupBy {
+    groupBy: TaggedTemplateQueryPart<this>
+    & ((columns: Partial<{[column in KeyOfTarget<this extends ConstructedQuery<infer E> ? E : never, never>]: any}>) => this)
+    & ((...expr: string[]) => this)
+    & ((ref: ref) => this)
+    // columns currently not being auto-completed due to complexity
+}
+
+interface Having<T> {
+    having: HavingWhere<this, T>
+}
+
+type HavingWhere<This, E> = 
+/**
+* @param predicate - An object with keys that are valid fields of the target entity and values that are compared to the respective fields.
+* @example
+* ```js
+* SELECT.from(Books).where({ ID: 42 })  // where ID is a valid field of Book
+* SELECT.from(Books).having({ ID: 42 })  // where ID is a valid field of Book
+* ```
+*/
+((predicate: Partial<{[column in KeyOfTarget<This extends ConstructedQuery<infer E> ? E : never, never>]: any}>) => This)
+/**
+* @param expr - An array of expressions, where every odd element is a valid field of the target entity and every even element is a value that is compared to the respective field.
+* @example
+* ```js
+* SELECT.from(Books).where(['ID =', 42 ])  // where ID is a valid, numerical field of Book
+* SELECT.from(Books).having(['ID =', 42 ])  // where ID is a valid, numerical field of Book
+*```
+*/
+& (<const L extends unknown[]>(...expr: Expressions<L, UnwrappedInstanceType<E>>) => This)
+& ((...expr: string[]) => This)
+& TaggedTemplateQueryPart<This>
+
 export const home: string;
 
 export const insert: Service['insert'];
@@ -1258,31 +1391,22 @@ type INSERT_2 = { INSERT: {
     }, }
 export { INSERT_2 as INSERT }
 
-class INSERT_3<T> extends ConstructedQuery {
-
-    static into: (<T extends ArrayConstructable<any>> (entity: T, entries?: object | object[]) => INSERT_3<SingularType<T>>)
-    & (TaggedTemplateQueryPart<INSERT_3<unknown>>)
-    & ((entity: Target, entries?: object | object[]) => INSERT_3<any>)
-    & (<T> (entity: Constructable<T>, entries?: object | object[]) => INSERT_3<T>)
-    & (<T> (entity: T, entries?: T | object | object[]) => INSERT_3<T>)
-
-    into: (<T extends ArrayConstructable> (entity: T) => this)
-    & TaggedTemplateQueryPart<this>
-    & ((entity: Target) => this)
-
-    data (block: (e: T) => void): this
-
-    entries (...entries: object[]): this
+interface INSERT_3<T> extends Columns<T>, InUpsert<T> {}
 
-    columns (...col: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]): this
+class INSERT_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
-    columns (...col: string[]): this
-
-    values (...val: any[]): this
-
-    rows (...row: any[]): this
+    static into: (<T extends ArrayConstructable> (entity: T, entries?: Entries) => INSERT_3<SingularInstanceType<T>>)
+    & (TaggedTemplateQueryPart<INSERT_3<unknown>>)
+    & ((entity: EntityDescription, entries?: Entries) => INSERT_3<StaticAny>)
+    & (<T> (entity: Constructable<T>, entries?: Entries) => INSERT_3<T>)
+    & (<T> (entity: T, entries?: T | Entries) => INSERT_3<T>)
 
+    /**
+     * @deprected
+     */
     as (select: SELECT_3<T>): this
+    from (select: SELECT_3<T>): this
     INSERT: CQN.INSERT['INSERT']
 
 }
@@ -1299,53 +1423,70 @@ type Intersect<T extends readonly unknown[]> = T extends [infer Head, ...infer T
 ? Head & Intersect<Tail>
 : unknown
 
+interface InUpsert<T> {
+    data (block: (e: T) => void): this
+
+    entries (...entries: object[]): this
+
+    values (...val: (null | Primitive)[]): this
+    values (val: (null | Primitive)[]): this
+
+    rows (...row: (null | Primitive)[][]): this
+    rows (row: (null | Primitive)[][]): this
+
+    into: (<T extends ArrayConstructable> (entity: T) => this)
+    & TaggedTemplateQueryPart<this>
+    & ((entity: EntityDescription) => this)
+}
+
 /**
  * Object structure that exposes both array-like and object-like behaviour.
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
  */
-type IterableMap<T> = { [name: string]: T } & _ArrayLike<T>
+
+type IterableMap<T> = { [name: string]: T } & Iterable<T>
 
 type JSON_2 = string
 export { JSON_2 as JSON }
 
 export type Key = number | string | any
 
-type kinds = 'aspect' | 'entity' | 'type' | 'event' | 'action' | 'function' | 'service' | 'context' | 'elements'
+type KeyOfSingular<T> = Unwrap<T> extends T
+? keyof T
+: keyof Unwrap<T>
+
+type KeyOfTarget<T, F = string | column_expr> = T extends ConstructedQuery<infer U>
+? (U extends ArrayConstructable  // Books
+? keyof SingularInstanceType<U>
+: U extends Constructable  // Book
+? keyof InstanceType<U>
+: F)
+: F
+
+type kinds = 'aspect' | 'entity' | 'type' | 'event' | 'action' | 'function' | 'service' | 'context' | 'elements' | 'element'
+
+/**
+ * T is a tuple of alternating K, V pairs -> true, else false
+ * Allows for variadic parameter lists with alternating expecing types,
+ * like we have in cql.SELECT.where
+ */
+type KVPairs<T,K,V> = T extends []
+? true
+: T extends [K, V, ...infer R]
+? KVPairs<R,K,V>
+: false
 
 class LargeBinary extends Binary { }
 
 class LargeString extends String_2 { }
 
 /**
- * Prepare a node module for lazy-loading submodules instead
- * of static requires. Example:
- *
- * @example
- * ```js
- *    require = lazify (module) //> turns require into a lazy one
- *    const facade = module.exports = {
- *       sub: require ('./sub-module')
- *    })
- * ```
- *
- * The first usage of `facade.sub` will load the sub module
- * using standard Node.js's `module.require` functions.
+ * @deprecated since version 8.1
  */
 export function lazified<T> (target: T): T
 
 /**
- * Equip a given facade object with getters for lazy-loading modules instead
- * of static requires. Example:
- *
- * @example
- * ```js
- *    const facade = lazify ({
- *       sub: lazy => require ('./sub-module')
- *    })
- * ```
- *
- * The first usage of `facade.sub` will load the sub module
- * using standard Node.js's `module.require` functions.
+ * @deprecated since version 8.1
  */
 export function lazify<T> (target: T): T
 
@@ -1355,6 +1496,11 @@ enum levels {
     SILENT = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4, TRACE = 5, SILLY = 5, VERBOSE = 5
 }
 
+interface Limit {
+    limit: TaggedTemplateQueryPart<this>
+    & ((rows: number, offset?: number) => this)
+}
+
 export const linked: {
 
     /**
@@ -1680,6 +1826,12 @@ export const middlewares: {
     add: (middleware: import('express').RequestHandler, pos?: XOR<XOR<{ at: number }, { after: Middleswares }>, { before: Middleswares }>) => void,
 };
 
+/**
+ * Minifies a given CSN model by removing all unused1 types and aspects, as well all entities tagged with `@cds.persistence.skip:'if-unused'`
+ * @see [capire](https://cap.cloud.sap/docs/node.js/cds-compile#cds-minify)
+ */
+export function minify (model: csn.CSN): csn.CSN
+
 /**
  * Allows arbitrary property access. Can be used for explicitly casting
  * classes you have added {@link mixin}s to.
@@ -1724,6 +1876,7 @@ namespace models {
         get,
         load,
         resolve,
+        minify,
         reflect,
         _flavor,
         _odata_options,
@@ -1777,6 +1930,9 @@ namespace models {
 /** @private */
 export type name = string
 
+/** @private */
+export type _named = { [key: name]: expr }
+
 const number: typeof number_;
 
 class number_ extends scalar { }
@@ -1849,6 +2005,8 @@ export interface OnEventHandler {
     (req: Request_2, next: Function): Promise<any> | any | void
 }
 
+type Op = '=' | '<' | '>' | '<=' | '>=' | '!=' | 'in' | 'like'
+
 /** @private */
 export type operator = string
 
@@ -1860,8 +2018,14 @@ export type _options = {
     odata?: _odata_options,
 } | _flavor
 
+interface OrderBy<T> {
+    orderBy: TaggedTemplateQueryPart<this>
+    & ((...col: KeyOfSingular<T>[]) => this)
+    & ((...expr: string[]) => this)
+}
+
 /** @private */
-export type ordering_term = expr & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
+export type ordering_term = UnionToIntersection<expr> & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
 
 export const outboxed: (service: Service) => Service;
 
@@ -1885,7 +2049,7 @@ export { Partial_2 as Partial }
 
 type PK = number | string | object
 
-type PluralType<T extends Constructable> = Array<InstanceType<T>>
+type PluralInstanceType<T extends Constructable> = Array<InstanceType<T>>
 
 export type predicate = UnionsToIntersections<_xpr>
 
@@ -1905,7 +2069,7 @@ export class Privileged extends User {
 
 }
 
-type Projection<T> = (e: QLExtensions<T extends ArrayConstructable ? SingularType<T> : T>) => void
+type Projection<T> = (e: QLExtensions<T extends ArrayConstructable ? SingularInstanceType<T> : T>) => void
 
 /**
  * @alpha
@@ -1917,42 +2081,32 @@ class QL<T> {
 
     SELECT: StaticSELECT<T>
 
-    INSERT: typeof INSERT_3
-    & ((...entries: object[]) => INSERT_3<any>) & ((entries: object[]) => INSERT_3<any>)
+    INSERT: typeof INSERT_3<T>
+    & ((...entries: object[]) => INSERT_3<T>) & ((entries: object[]) => INSERT_3<T>)
 
     UPSERT: typeof UPSERT_3
-    & ((...entries: object[]) => UPSERT_3<any>) & ((entries: object[]) => UPSERT_3<any>)
+    & ((...entries: object[]) => UPSERT_3<T>) & ((entries: object[]) => UPSERT_3<T>)
 
-    UPDATE: typeof UPDATE_3
-    & typeof UPDATE_3.entity
+    UPDATE: typeof UPDATE_3<T>
+    & typeof UPDATE_3.entity<_TODO_2>
 
-    DELETE: typeof DELETE_3
-    & ((...entries: object[]) => DELETE_3<any>) & ((entries: object[]) => DELETE_3<any>)
+    DELETE: typeof DELETE_3<T>
+    & ((...entries: object[]) => DELETE_3<T>) & ((entries: object[]) => DELETE_3<T>)
 
-    CREATE: typeof CREATE_3
+    CREATE: typeof CREATE_3<T>
 
-    DROP: typeof DROP_3
+    DROP: typeof DROP_3<T>
 
 }
 
 namespace ql {
     export {
         Query_2 as Query,
-        ConstructedQuery,
-        PK,
-        Primitive,
         QLExtensions,
-        Target,
-        QLExtensions_,
-        Subqueryable,
-        Projection,
-        Awaitable,
+        ConstructedQuery,
         StaticSELECT,
         QL,
-        TaggedTemplateQueryPart,
         SELECT_3 as SELECT,
-        SELECT_one,
-        SELECT_from,
         INSERT_3 as INSERT,
         UPSERT_3 as UPSERT,
         DELETE_3 as DELETE,
@@ -1963,35 +2117,20 @@ namespace ql {
 }
 export { ql }
 
-export type QLExtensions<T> = T extends QLExtensions_<any> ? T : QLExtensions_<T>
+export type QLExtensions<T> = T extends QLExtensions_<any> ? T : QLExtensions_<DeepRequired<T>>
 
 /**
  * QLExtensions are properties that are attached to entities in CQL contexts.
  * They are passed down to all properties recursively.
  */
-type QLExtensions_<T> = {
-    [Key in keyof T]: QLExtensions<T[Key]>
-} & {
-
-    /**
-     	 * Alias for this attribute.
-     	 */
-    as: (alias: string) => void,
-
-    /**
-     	 * Accesses any nested attribute based on a [path](https://cap.cloud.sap/cap/docs/java/query-api#path-expressions):
-     	 * `X.get('a.b.c.d')`. Note that you will not receive
-     	 * proper typing after this call.
-     	 * To still have access to typed results, use
-     	 * `X.a().b().c().d()` instead.
-     	 */
-    get: (path: string) => any,
-
-    // have to exclude undefined from the type, or we'd end up with a distribution of Subqueryable
-    // over T and undefined, which gives us zero code completion within the callable.
-} & Subqueryable<Exclude<T, undefined>>
+// have to exclude undefined from the type, or we'd end up with a distribution of Subqueryable
+// over T and undefined, which gives us zero code completion within the callable.
+type QLExtensions_<T> = { [Key in keyof T]: QLExtensions<T[Key]> } & QueryArtefact & Subqueryable<Exclude<T, undefined>>
 
-export type Query = Partial<SELECT_2 & INSERT_2 & UPDATE_2 & DELETE_2 & CREATE_2 & DROP_2 & UPSERT_2>
+export type Query = { 
+    /** @since 7.4.0 */
+    elements: { [key: string]: Definition },
+} & Partial<SELECT_2 & INSERT_2 & UPDATE_2 & DELETE_2 & CREATE_2 & DROP_2 & UPSERT_2>
 
 type Query_2 = CQN.Query
 
@@ -2043,7 +2182,7 @@ export class QueryAPI {
      * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
      */
     run: {
-        (query: ConstructedQuery | ConstructedQuery[]): Promise<ResultSet | any>,
+        (query: ConstructedQuery<_TODO_2> | ConstructedQuery<_TODO_2>[]): Promise<ResultSet | any>,
         (query: Query_2): Promise<ResultSet | any>,
         (query: string, args?: any[] | object): Promise<ResultSet | any>,
     }
@@ -2083,10 +2222,28 @@ export class QueryAPI {
 
 }
 
+type QueryArtefact = {
+
+    /**
+     	 * Alias for this attribute.
+     	 */
+    as (alias: string): void,
+
+    /**
+     	 * Accesses any nested attribute based on a [path](https://cap.cloud.sap/cap/docs/java/query-api#path-expressions):
+     	 * `X.get('a.b.c.d')`. Note that you will not receive
+     	 * proper typing after this call.
+     	 * To still have access to typed results, use
+     	 * `X.a().b().c().d()` instead.
+     	 */
+    get (path: string): any,
+
+}
+
 export const read: Service['read'];
 
 /** @private */
-export type ref = { ref: (name & { id?: string, where?: expr, args?: expr[] })[] }
+export type ref = { ref: _segment[] }
 
 /**
  * Turns the given plain CSN model into a reflected model
@@ -2191,6 +2348,17 @@ class scalar extends type { }
 
 type Scalarise<A> = A extends Array<infer N> ? N : A
 
+/** @private */
+export type _segment = name | {
+    id?: string,
+    where?: _xpr,
+    args?: _named,
+    groupBy: expr[],
+    having: _xpr,
+    orderBy: ordering_term[],
+    limit: { rows: expr, offset: expr },
+}
+
 type SELECT_2 = { SELECT: {
         distinct?: true,
         one?: boolean,
@@ -2199,51 +2367,36 @@ type SELECT_2 = { SELECT: {
         columns?: column_expr[],
         excluding?: string[],
         where?: predicate,
-        having?: predicate,
         groupBy?: expr[],
+        having?: predicate,
         orderBy?: ordering_term[],
         limit?: { rows: val, offset: val },
+        forUpdate?: { wait: number },
+        forShareLock?: { wait: number },
+        search?: predicate,
+        count?: boolean,
     }, }
 export { SELECT_2 as SELECT }
 
-class SELECT_3<T> extends ConstructedQuery {
-
-    static one: SELECT_one & { from: SELECT_one }
-
-    static distinct: typeof SELECT_3
-
-    static from: SELECT_from
+interface SELECT_3<T> extends Where<T>, And, Having<T>, GroupBy, OrderBy<T>, Limit {
+    // overload specific to SELECT
+    columns: Columns<T, this>['columns'] & ((projection: Projection<T>) => this)
+}
 
-    from: SELECT_from & TaggedTemplateQueryPart<this>
-    & ((entity: Target, primaryKey?: PK, projection?: Projection<unknown>) => this)
+class SELECT_3<T, Q = SELECT_from> extends ConstructedQuery<T> {
+    private constructor();
 
-    byKey (primaryKey?: PK): this
-    columns: TaggedTemplateQueryPart<this>
-    & ((projection: Projection<T>) => this)
-    & ((...col: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]) => this)
-    & ((...col: (string | column_expr)[]) => this)
-    & ((col: (string | column_expr)[]) => this)
-
-    where: TaggedTemplateQueryPart<this>
-    & ((predicate: object) => this)
-    & ((...expr: any[]) => this)
+    static one: SELECT_one & { from: SELECT_one } & { localized: SELECT_one }
 
-    and: TaggedTemplateQueryPart<this>
-    & ((predicate: object) => this)
-    & ((...expr: any[]) => this)
-
-    having: TaggedTemplateQueryPart<this>
-    & ((...expr: string[]) => this)
-    & ((predicate: object) => this)
+    static distinct: typeof SELECT_3<StaticAny>
 
-    groupBy: TaggedTemplateQueryPart<this>
-    & ((...expr: string[]) => this)
+    static from: SELECT_from & { localized: SELECT_from }
 
-    orderBy: TaggedTemplateQueryPart<this>
-    & ((...expr: string[]) => this)
+    static localized: SELECT_from & { from: SELECT_from }
 
-    limit: TaggedTemplateQueryPart<this>
-    & ((rows: number, offset?: number) => this)
+    from: Q  // SELECT_from | SELECT_one
+    & TaggedTemplateQueryPart<this>
+    & ((entity: EntityDescription, primaryKey?: PK, projection?: Projection<unknown>) => this)
 
     forShareLock (): this
 
@@ -2274,52 +2427,61 @@ class SELECT_3<T> extends ConstructedQuery {
 
 type SELECT_from =
 // tagged template
-TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
+TaggedTemplateQueryPart<Awaitable<SELECT_3<_TODO_2>, InstanceType<_TODO_2>>>
 &
 // calling with class
-(<T extends ArrayConstructable<any>>
-(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
-=> Awaitable<SELECT_3<T>, InstanceType<T>>)
+(<E extends ArrayConstructable>
+(entityType: E, projection?: Projection<QLExtensions<SingularInstanceType<E>>>)
+=> Awaitable<SELECT_3<E>, InstanceType<E>>)
 &
-(<T extends ArrayConstructable<any>>
-(entityType: T, primaryKey: PK, projection?: Projection<SingularType<T>>)
-=> Awaitable<SELECT_3<SingularType<T>>, InstanceType<SingularType<T>>>) // when specifying a key, we expect a single element as result
+(<E extends ArrayConstructable>
+(entityType: E, primaryKey: PK, projection?: Projection<SingularInstanceType<E>>)
+=> Awaitable<SELECT_3<SingularInstanceType<E>>, SingularInstanceType<E>>) // when specifying a key, we expect a single element as result
 // calling with definition
-& ((entity: Target, primaryKey?: PK, projection?: Projection<unknown>) => SELECT_3<any>)
+& (<T>(entity: EntityDescription, primaryKey?: PK, projection?: Projection<T>) => SELECT_3<T>)
 // calling with concrete list
 & (<T> (entity: T[], projection?: Projection<T>) => SELECT_3<T> & Promise<T[]>)
 & (<T> (entity: T[], primaryKey: PK, projection?: Projection<T>) => Awaitable<SELECT_3<T>, T>)
-& ((subject: ref) => SELECT_3<any>)
+& ((subject: ref) => SELECT_3<_TODO_2>)
 // put these overloads at the very end, as they would also match the above
 // We expect these to be the overloads for scalars since we covered arrays above -> wrap them back in Array
-& (<T extends Constructable<any>>(
+& (<T extends Constructable>(
+entityType: T,
+columns: string[]  // could be keyof in the future
+) => Awaitable<SELECT_3<PluralInstanceType<T>>, PluralInstanceType<T>>)
+& (<T extends Constructable>(
+entityType: T,
+primaryKey: PK,
+columns: string[]  // could be keyof in the future
+) => Awaitable<SELECT_3<InstanceType<T>>, InstanceType<T>>)
+& (<T extends Constructable>(
 entityType: T,
 projection?: Projection<InstanceType<T>>
-) => Awaitable<SELECT_3<PluralType<T>>, PluralType<T>>)
-& (<T extends Constructable<any>>(
+) => Awaitable<SELECT_3<PluralInstanceType<T>>, PluralInstanceType<T>>)
+& (<T extends Constructable>(
 entityType: T,
 primaryKey: PK,
 projection?: Projection<InstanceType<T>>
-) => Awaitable<SELECT_3<PluralType<T>>, PluralType<T>>)
+) => Awaitable<SELECT_3<InstanceType<T>>, InstanceType<T>>)
 
 type SELECT_one =
-TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
+TaggedTemplateQueryPart<Awaitable<SELECT_3<_TODO_2, SELECT_one>, InstanceType<_TODO_2>>>
 &
 // calling with class
-(<T extends ArrayConstructable<any>>
-(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
-=> Awaitable<SELECT_3<SingularType<T>>, SingularType<T>>)
+(<T extends ArrayConstructable>
+(entityType: T, projection?: Projection<QLExtensions<SingularInstanceType<T>>>)
+=> Awaitable<SELECT_3<SingularInstanceType<T>, SELECT_one>, SingularInstanceType<T>>)
 &
-(<T extends ArrayConstructable<any>>
-(entityType: T, primaryKey: PK, projection?: Projection<QLExtensions<SingularType<T>>>)
-=> Awaitable<SELECT_3<SingularType<T>>, SingularType<T>>)
+(<T extends ArrayConstructable>
+(entityType: T, primaryKey: PK, projection?: Projection<QLExtensions<SingularInstanceType<T>>>)
+=> Awaitable<SELECT_3<SingularInstanceType<T>, SELECT_one>, SingularInstanceType<T>>)
 
-& ((entity: Target, primaryKey?: PK, projection?: Projection<unknown>) => SELECT_3<any>)
-& (<T> (entity: T[], projection?: Projection<T>) => Awaitable<SELECT_3<T>, T>)
-& (<T> (entity: T[], primaryKey: PK, projection?: Projection<T>) => Awaitable<SELECT_3<T>, T>)
-& (<T> (entity: { new(): T }, projection?: Projection<T>) => Awaitable<SELECT_3<T>, T>)
-& (<T> (entity: { new(): T }, primaryKey: PK, projection?: Projection<T>) => Awaitable<SELECT_3<T>, T>)
-& ((subject: ref) => SELECT_3<any>)
+& ((entity: EntityDescription, primaryKey?: PK, projection?: Projection<unknown>) => SELECT_3<_TODO_2, SELECT_one>)
+& (<T> (entity: T[], projection?: Projection<T>) => Awaitable<SELECT_3<T, SELECT_one>, T>)
+& (<T> (entity: T[], primaryKey: PK, projection?: Projection<T>) => Awaitable<SELECT_3<T, SELECT_one>, T>)
+& (<T> (entity: { new(): T }, projection?: Projection<T>) => Awaitable<SELECT_3<T, SELECT_one>, T>)
+& (<T> (entity: { new(): T }, primaryKey: PK, projection?: Projection<T>) => Awaitable<SELECT_3<T, SELECT_one>, T>)
+& ((subject: ref) => SELECT_3<_TODO_2>)
 
 /**
  	 * Constructs service providers from respective service definitions
@@ -2415,7 +2577,7 @@ export class Service extends QueryAPI {
         <T = any>(event: types.event, path: string, data?: object, headers?: object): Promise<T>,
         <T = any>(event: types.event, data?: object, headers?: object): Promise<T>,
         <T = any>(details: { event: types.event, data?: object, headers?: object }): Promise<T>,
-        <T = any>(details: { query: ConstructedQuery, data?: object, headers?: object }): Promise<T>,
+        <T = any>(details: { query: ConstructedQuery<T>, data?: object, headers?: object }): Promise<T>,
         <T = any>(details: { method: types.eventName, path: string, data?: object, headers?: object }): Promise<T>,
         <T = any>(details: { event: types.eventName, entity: linked_2.Definition | string, data?: object, params?: object, headers?: object }): Promise<T>,
     }
@@ -2462,8 +2624,8 @@ export class Service extends QueryAPI {
     // Provider API
     prepend (fn: ServiceImpl): this
 
-    on<T extends ArrayConstructable>(eve: types.event, entity: T, handler: CRUDEventHandler.On<Unwrap<T>>): this
-    on<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.On<InstanceType<T>>): this
+    on<T extends ArrayConstructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.On<Unwrap<T>>): this
+    on<T extends Constructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.On<InstanceType<T>>): this
     on<F extends CdsFunction>(boundAction: F, service: string, handler: ActionEventHandler<F['__parameters'], void | Error | F['__returns']>): this
     on<F extends CdsFunction>(unboundAction: F, handler: ActionEventHandler<F['__parameters'], void | Error | F['__returns']>): this
     on (eve: types.event, entity: types.target, handler: OnEventHandler): this
@@ -2476,8 +2638,8 @@ export class Service extends QueryAPI {
     // onFailed (eve: types.Events, handler: types.EventHandler): this
     before<F extends CdsFunction>(boundAction: F, service: string, handler: CRUDEventHandler.Before<F['__parameters'], void | Error | F['__returns']>): this
     before<F extends CdsFunction>(unboundAction: F, handler: CRUDEventHandler.Before<F['__parameters'], void | Error | F['__returns']>): this
-    before<T extends ArrayConstructable>(eve: types.event, entity: T, handler: CRUDEventHandler.Before<Unwrap<T>>): this
-    before<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.Before<InstanceType<T>>): this
+    before<T extends ArrayConstructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.Before<Unwrap<T>>): this
+    before<T extends Constructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.Before<InstanceType<T>>): this
     before (eve: types.event, entity: types.target, handler: EventHandler): this
     before (eve: types.event, handler: EventHandler): this
 
@@ -2486,11 +2648,11 @@ export class Service extends QueryAPI {
     // (3) check if T is scalar -> use T directly
     // this streamlines that in _most_ cases, handlers will receive a single object.
     // _Except_ for after.read handlers (1), which will change its inflection based on T.
-    after<T extends ArrayConstructable>(event: 'READ', entity: T, handler: CRUDEventHandler.After<InstanceType<T>>): this
-    after<T extends ArrayConstructable>(event: 'each', entity: T, handler: CRUDEventHandler.After<Unwrap<T>>): this
-    after<T extends Constructable>(event: 'READ' | 'each', entity: T, handler: CRUDEventHandler.After<InstanceType<T>>): this
-    after<T extends ArrayConstructable>(eve: types.event, entity: T, handler: CRUDEventHandler.After<Unwrap<T>>): this
-    after<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.After<InstanceType<T>>): this
+    after<T extends ArrayConstructable>(event: 'READ', entity: T | T[], handler: CRUDEventHandler.After<InstanceType<T>>): this
+    after<T extends ArrayConstructable>(event: 'each', entity: T | T[], handler: CRUDEventHandler.After<Unwrap<T>>): this
+    after<T extends Constructable>(event: 'READ' | 'each', entity: T | T[], handler: CRUDEventHandler.After<InstanceType<T>>): this
+    after<T extends ArrayConstructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.After<Unwrap<T>>): this
+    after<T extends Constructable>(eve: types.event, entity: T | T[], handler: CRUDEventHandler.After<InstanceType<T>>): this
     after<F extends CdsFunction>(boundAction: F, service: string, handler: CRUDEventHandler.After<F['__parameters'], void | Error | F['__returns']>): this
     after<F extends CdsFunction>(unboundAction: F, handler: CRUDEventHandler.After<F['__parameters'], void | Error | F['__returns']>): this
     after (eve: types.event, entity: types.target, handler: ResultsHandler): this
@@ -2556,7 +2718,7 @@ export interface ServiceImpl {
  	 */
 export const services: cds_services;
 
-type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+type SingularInstanceType<T extends ArrayConstructable> = InstanceType<T>[number]
 
 /** @private */
 export type source = UnionToIntersection<ref | SELECT_2> & { as?: name, join?: name, on?: xpr }
@@ -2593,11 +2755,11 @@ export type SpawnOptions = {
 
 export type SQL = string
 
-type StaticSELECT<T> = typeof SELECT_3
-& ((...columns: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]) => SELECT_3<T>)
-& ((...columns: string[]) => SELECT_3<T>)
-& ((columns: string[]) => SELECT_3<T>)
-& (TaggedTemplateQueryPart<SELECT_3<T>>)
+type StaticAny = any
+
+type StaticSELECT<T> = { columns: SELECT_3<T>['columns'] }
+& typeof SELECT_3<T>
+& SELECT_3<T>['columns']
 & SELECT_from // as it is not directly quantified, ...
 & SELECT_one
 
@@ -2605,7 +2767,9 @@ export const stream: Service['stream'];
 
 const string: typeof string_;
 
-class string_ extends scalar { }
+class string_ extends scalar { 
+    length?: number
+}
 
 class String_2 extends string { }
 
@@ -2635,7 +2799,7 @@ interface struct_2 extends type_2 {
  * The final result of each subquery will be the property itself:
  * `Book.title` == `Subqueryable<Book>.title()`
  */
-type Subqueryable<T> = T extends Primitive	? unknown
+type Subqueryable<T> = T extends Primitive ? unknown
 // composition of many/ association to many
 : T extends readonly unknown[] ? {
 
@@ -2679,10 +2843,7 @@ type Subqueryable<T> = T extends Primitive	? unknown
 
 type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params: unknown[]) => T
 
-/**
- * Target for any QL operation
- */
-type Target = linked_2.classes.entity | Definition | string
+type TaggedTemplateRequest = (strings: TemplateStringsArray, ...params: unknown[]) => Promise<import('axios').AxiosResponse>
 
 class Test extends Axios {
 
@@ -2738,6 +2899,8 @@ export const test: {
     (command: string, ...args: string[]): Test,
 
     in (dirname: string): Test,
+
+    log: Test['log'],
 };
 
 class Time extends date { }
@@ -2750,6 +2913,9 @@ class TimeStamp extends DateTime { }
  */
 export type _TODO = any
 
+/** @internal */
+type _TODO_2 = any
+
 export interface Transaction extends Service {
     commit(): Promise<void>
     rollback(): Promise<void>
@@ -2768,13 +2934,21 @@ export const tx: {
 };
 
 export interface type extends Omit<csn.type, 'items'> {
-    items: type
+    items?: type
+    key?: boolean
+    notNull?: boolean
+    virtual?: boolean
 }
 
 export class type<K extends kinds = 'type'> extends any_<K> { }
 
 interface type_2 extends any__2 {
-    type?: FQN
+    type?: 'cds.Boolean' |
+    'cds.UUID' | 'cds.String' | 'cds.LargeString' | 'cds.Binary' | 'cds.LargeBinary' | 'cds.Vector' |
+    'cds.Integer' | 'cds.UInt8' | 'cds.Int16' | 'cds.Int32' | 'cds.Int64' | 'cds.Float' | 'cds.Double' | 'cds.Decimal' |
+    'cds.Date' | 'cds.Time' | 'cds.DateTime' | 'cds.Timestamp' |
+    'cds.Association' | 'cds.Composition' |
+    FQN & Record<never,never> // allow any other CDS type as well (e.g. 'User')
     items?: type_2
 }
 
@@ -2799,11 +2973,13 @@ type UnionsToIntersections<U> = Array<UnionToIntersection<Scalarise<U>>>
 type UnionToIntersection<U> = Partial<(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never>
 
 type Unwrap<T> = T extends ArrayConstructable
-? SingularType<T>
+? SingularInstanceType<T>
 : T extends Array<infer U>
 ? U
 : T
 
+type UnwrappedInstanceType<T> = Unwrap<T> extends Constructable ? InstanceType<Unwrap<T>> : Unwrap<T>
+
 export const update: Service['update'];
 
 type UPDATE_2 = { UPDATE: {
@@ -2813,18 +2989,22 @@ type UPDATE_2 = { UPDATE: {
     }, }
 export { UPDATE_2 as UPDATE }
 
-class UPDATE_3<T> extends ConstructedQuery {
+interface UPDATE_3<T> extends Where<T>, And, ByKey {}
+
+class UPDATE_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
     // cds-typer plural
-    static entity<T extends ArrayConstructable<any>> (entity: T, primaryKey?: PK): UPDATE_3<SingularType<T>>
+    // FIXME: this returned UPDATE<SingularInstanceType<T>> before. should UPDATE<Books>.entity(...) return Book or Books?
+    static entity<T extends ArrayConstructable> (entity: T, primaryKey?: PK): UPDATE_3<InstanceType<T>>
 
-    static entity (entity: Target, primaryKey?: PK): UPDATE_3<any>
+    static entity (entity: EntityDescription, primaryKey?: PK): UPDATE_3<StaticAny>
 
-    static entity<T> (entity: Constructable<T>, primaryKey?: PK): UPDATE_3<T>
+    static entity<T extends Constructable> (entity: T, primaryKey?: PK): UPDATE_3<T>
 
+    // currently no easy way to restrict T from being a primitive type
     static entity<T> (entity: T, primaryKey?: PK): UPDATE_3<T>
 
-    byKey (primaryKey?: PK): this
     // with (block: (e:T)=>void) : this
     // set (block: (e:T)=>void) : this
     set: TaggedTemplateQueryPart<this>
@@ -2833,13 +3013,6 @@ class UPDATE_3<T> extends ConstructedQuery {
     with: TaggedTemplateQueryPart<this>
     & ((data: object) => this)
 
-    where (predicate: object): this
-
-    where (...expr: any[]): this
-
-    and (predicate: object): this
-
-    and (...expr: any[]): this
     UPDATE: CQN.UPDATE['UPDATE']
 
 }
@@ -2853,29 +3026,19 @@ type UPSERT_2 = { UPSERT: {
     }, }
 export { UPSERT_2 as UPSERT }
 
-class UPSERT_3<T> extends ConstructedQuery {
-
-    static into: (<T extends ArrayConstructable<any>> (entity: T, entries?: object | object[]) => UPSERT_3<SingularType<T>>)
-    & (TaggedTemplateQueryPart<UPSERT_3<unknown>>)
-    & ((entity: Target, entries?: object | object[]) => UPSERT_3<any>)
-    & (<T> (entity: Constructable<T>, entries?: object | object[]) => UPSERT_3<T>)
-    & (<T> (entity: T, entries?: T | object | object[]) => UPSERT_3<T>)
-
-    into: (<T extends ArrayConstructable> (entity: T) => this)
-    & TaggedTemplateQueryPart<this>
-    & ((entity: Target) => this)
+interface UPSERT_3<T> extends Columns<T>, InUpsert<T> {}
 
-    data (block: (e: T) => void): this
+class UPSERT_3<T> extends ConstructedQuery<T> {
+    private constructor();
 
-    entries (...entries: object[]): this
+    static into: (<T extends ArrayConstructable> (entity: T, entries?: Entries) => UPSERT_3<SingularInstanceType<T>>)
+    & (TaggedTemplateQueryPart<UPSERT_3<StaticAny>>)
+    & ((entity: EntityDescription, entries?: Entries) => UPSERT_3<StaticAny>)
+    & (<T> (entity: Constructable<T>, entries?: Entries) => UPSERT_3<T>)
+    // currently no easy way to restrict T to non-primitives
+    & (<T> (entity: T, entries?: T | Entries) => UPSERT_3<T>)
 
-    columns (...col: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]): this
 
-    columns (...col: string[]): this
-
-    values (...val: any[]): this
-
-    rows (...row: any[]): this
     UPSERT: CQN.UPSERT['UPSERT']
 
 }
@@ -2910,7 +3073,7 @@ export class User {
 }
 
 /**
- * Provides a set of utility functionss
+ * Provides a set of utility functions
  */
 export const utils: {
 
@@ -2996,6 +3159,59 @@ export const utils: {
      	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rm-path
      	 */
     rm: (...path: string[]) => Promise<ReturnType<typeof import('node:fs').promises.rm>>,
+
+    /**
+     * @since 8.3.0
+     * @see https://cap.cloud.sap/docs/node.js/cds-utils#colors
+     */
+    colors: {
+        enabled: boolean,
+        RESET: '\x1b[0m',
+        BOLD: '\x1b[1m' | '',
+        BRIGHT: '\x1b[1m' | '',
+        DIMMED: '\x1b[2m' | '',
+        ITALIC: '\x1b[3m' | '',
+        UNDER: '\x1b[4m' | '',
+        BLINK: '\x1b[5m' | '',
+        FLASH: '\x1b[6m' | '',
+        INVERT: '\x1b[7m' | '',
+        BLACK: '\x1b[30m' | '',
+        RED: '\x1b[31m' | '',
+        GREEN: '\x1b[32m' | '',
+        YELLOW: '\x1b[33m' | '',
+        BLUE: '\x1b[34m' | '',
+        PINK: '\x1b[35m' | '',
+        CYAN: '\x1b[36m' | '',
+        LIGHT_GRAY: '\x1b[37m' | '',
+        DEFAULT: '\x1b[39m' | '',
+        GRAY: '\x1b[90m' | '',
+        LIGHT_RED: '\x1b[91m' | '',
+        LIGHT_GREEN: '\x1b[92m' | '',
+        LIGHT_YELLOW: '\x1b[93m' | '',
+        LIGHT_BLUE: '\x1b[94m' | '',
+        LIGHT_PINK: '\x1b[95m' | '',
+        LIGHT_CYAN: '\x1b[96m' | '',
+        WHITE: '\x1b[97m' | '',
+        bg: {
+            BLACK: '\x1b[40m' | '',
+            RED: '\x1b[41m' | '',
+            GREEN: '\x1b[42m' | '',
+            YELLOW: '\x1b[43m' | '',
+            BLUE: '\x1b[44m' | '',
+            PINK: '\x1b[45m' | '',
+            CYAN: '\x1b[46m' | '',
+            WHITE: '\x1b[47m' | '',
+            DEFAULT: '\x1b[49m' | '',
+            LIGHT_GRAY: '\x1b[100m' | '',
+            LIGHT_RED: '\x1b[101m' | '',
+            LIGHT_GREEN: '\x1b[102m' | '',
+            LIGHT_YELLOW: '\x1b[103m' | '',
+            LIGHT_BLUE: '\x1b[104m' | '',
+            LIGHT_PINK: '\x1b[105m' | '',
+            LIGHT_CYAN: '\x1b[106m' | '',
+            LIGHT_WHITE: '\x1b[107m' | '',
+        },
+    },
 };
 
 class UUID extends string { }
@@ -3009,6 +3225,10 @@ export const version: string;
 
 type Visitor = (def: any_, name: string, parent: any_, defs: Definitions) => void
 
+interface Where<T> {
+    where: HavingWhere<this, T>
+}
+
 interface WithElements {
     elements: Definitions<type>
 }
@@ -3019,6 +3239,8 @@ interface WithElements {
  */
 type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
 
+type WS = '' | ' '
+
 export type XML = string
 
 /** @internal */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-types",
-  "version": "0.6.5",
+  "version": "0.8.0",
   "description": "Type definitions for main packages of CAP, like `@sap/cds`",
   "repository": "github:cap-js/cds-types",
   "homepage": "https://cap.cloud.sap/",
@@ -29,7 +29,8 @@
     "lint:fix": "npx eslint . --fix",
     "setup": "npm i && npm i file:. --no-save --force",
     "prerelease:ci-fix": "node .github/prerelease-fix.js",
-    "postinstall": "node ./scripts/postinstall.js"
+    "postinstall": "node ./scripts/postinstall.js",
+    "dependencies": "node ./scripts/postinstall.js"
   },
   "peerDependencies": {
     "@sap/cds": "^8.0.0"