@cap-js/cds-types 0.4.0 → 0.6.0

package/dist/cds-types.d.ts

@@ -1,23 +1,79 @@
-import { Application } from 'express';
-import { AxiosInstance } from 'axios';
-import chai from 'chai';
-import * as express from 'express';
-import * as fs from 'node:fs';
-import * as http from 'http';
-import { ReadableStream } from 'node:stream/web';
-import { RequestHandler } from 'express';
-
-export declare class action extends any_<'action' | 'function'> {}
-
-export declare interface ActionEventHandler<P, R> {
+declare module '@sap/cds' {
+
+
+export type __any_ = classes.any_
+
+export type __array = classes.array
+
+export type __aspect = classes.aspect
+
+export type __Association = classes.Association
+
+export type __Binary = classes.Binary
+
+export type __Boolean = classes.Boolean
+
+export type __Composition = classes.Composition
+
+export type __context_ = classes.context_
+
+export type __Date = classes.Date
+
+export type __date = classes.date
+
+export type __DateTime = classes.DateTime
+
+export type __Decimal = classes.Decimal
+
+export type __Double = classes.Double
+
+export type __entity = classes.entity
+
+export type __Float = classes.Float
+
+export type __Int16 = classes.Int16
+
+export type __Int32 = classes.Int32
+
+export type __Int64 = classes.Int64
+
+export type __Integer = classes.Integer
+
+export type __LargeBinary = classes.LargeBinary
+
+export type __LargeString = classes.LargeString
+
+export type __scalar = classes.scalar
+
+export type __service = classes.service_
+
+export type __String = classes.String
+
+export type __struct = classes.struct
+
+export type __Time = classes.Time
+
+export type __TimeStamp = classes.TimeStamp
+
+export type __type = classes.type
+
+export type __UInt8 = classes.UInt8
+
+export type __UUID = classes.UUID
+
+export type __Vector = classes.Vector
+
+class action extends any_<'action' | 'function'> {}
+
+export interface ActionEventHandler<P, R> {
     (req: Omit<Request_2, 'data'> & { data: P }, next: Function): Promise<R> | R
 }
 
-export declare const any: typeof any_;
+const any: typeof any_;
 
-export declare interface any_ extends csn.any_ {}
+interface any_ extends csn.any_ {}
 
-export declare class any_<K extends kinds = kinds> {
+class any_<K extends kinds = kinds> {
     private _: K // break covariance
     constructor (...aspects: any[])
 
@@ -26,15 +82,15 @@ export declare class any_<K extends kinds = kinds> {
     // is (kind: kinds | 'Association' | 'Composition'): boolean
 }
 
-declare interface any__2 {
+interface any__2 {
     kind?: kinds
 }
 
-export declare class ApplicationService extends Service {}
+export class ApplicationService extends Service {}
 
-export declare class array extends type<'type' | 'elements'> { }
+export class array extends type<'type' | 'elements'> { }
 
-declare interface ArrayConstructable<T = any> {
+interface ArrayConstructable<T = any> {
     new(...args: any[]): T[]
 }
 
@@ -44,7 +100,7 @@ declare interface ArrayConstructable<T = any> {
  * @internal
  * @since cds 7.9
  */
-declare type _ArrayLike<T> = Iterable<T> & {
+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>,
@@ -52,16 +108,16 @@ declare type _ArrayLike<T> = Iterable<T> & {
     find: (predicate: (element: T) => boolean) => T | undefined,
 }
 
-export declare class aspect<K extends kinds = 'aspect'> extends type<K> implements WithElements {
+class aspect<K extends kinds = 'aspect'> extends type<K> implements WithElements {
     elements: Definitions<type<'type'>>
 }
 
 /**
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-association)
  */
-export declare interface Association extends Omit<csn.Association, 'type' | 'items'> {}
+export interface Association extends Omit<csn.Association, 'type' | 'items'> {}
 
-export declare class Association extends type {
+export class Association extends type {
     _target: entity
 
     isAssociation: true
@@ -72,7 +128,7 @@ export declare class Association extends type {
 
 }
 
-declare interface Association_2 extends type_2 {
+interface Association_2 extends type_2 {
     type: 'cds.Association' | 'cds.Composition'
     target: FQN
 
@@ -92,22 +148,22 @@ declare interface Association_2 extends type_2 {
     keys?: (ref & { as: string })[]
 }
 
-declare type Awaitable<T, I> = T & Promise<I>
+type Awaitable<T, I> = T & Promise<I>
 
-declare class Axios {
+class Axios {
 
-    get axios (): AxiosInstance
-    get: AxiosInstance['get'];
+    get axios (): import('axios').AxiosInstance
+    get: import('axios').AxiosInstance['get'];
 
-    put: AxiosInstance['put']
+    put: import('axios').AxiosInstance['put']
 
-    post: AxiosInstance['post']
+    post: import('axios').AxiosInstance['post']
 
-    patch: AxiosInstance['patch']
+    patch: import('axios').AxiosInstance['patch']
 
-    delete: AxiosInstance['delete']
+    delete: import('axios').AxiosInstance['delete']
 
-    options: AxiosInstance['options']
+    options: import('axios').AxiosInstance['options']
 
     get GET (): Axios['get']
 
@@ -123,16 +179,15 @@ declare class Axios {
 
 }
 
-export declare class Binary extends string { }
+class Binary extends string { }
 
-export declare const boolean: typeof boolean_;
+const boolean: typeof boolean_;
 
-declare class boolean_ extends scalar { }
+class boolean_ extends scalar { }
 
-declare class Boolean_2 extends boolean { }
-export { Boolean_2 as Boolean }
+class Boolean_2 extends boolean { }
 
-export declare const builtin: {
+export const builtin: {
 
     /**
      * @see {@link models.linked.classes}
@@ -141,9 +196,9 @@ export declare const builtin: {
     types: Record<string, object>, // FIXME: value should be any class part of linked.classes
 };
 
-export declare type CDL = string
+export type CDL = string
 
-declare namespace cds {
+namespace cds {
     export {
         log,
         debug,
@@ -201,6 +256,37 @@ declare namespace cds {
         model,
         parse,
         linked,
+        __type,
+        __aspect,
+        __any_,
+        __scalar,
+        __Boolean,
+        __UUID,
+        __String,
+        __LargeString,
+        __Binary,
+        __LargeBinary,
+        __Vector,
+        __Integer,
+        __UInt8,
+        __Int16,
+        __Int32,
+        __Int64,
+        __Float,
+        __Double,
+        __Decimal,
+        __date,
+        __Date,
+        __Time,
+        __DateTime,
+        __TimeStamp,
+        __array,
+        __struct,
+        __context_,
+        __service,
+        __entity,
+        __Association,
+        __Composition,
         compile,
         spawn,
         Key,
@@ -270,10 +356,41 @@ declare namespace cds {
         operator,
         function_call,
         enum_literal,
-        expr_literal,
-        ModelPart,
-        Definition,
-        CSN,
+        expr_literal
+    }
+}
+
+export type _cds = typeof cds
+
+type _cds_2 = typeof cds
+
+export interface cds_connect_options {
+    impl?: string
+    service?: string
+    kind?: string
+    model?: string
+    credentials?: object
+}
+
+export interface cds_serve_fluent {
+    from (model: string | CSN): cds_serve_fluent
+    to (protocol: string): cds_serve_fluent
+    at (path: string): cds_serve_fluent
+    in (app: import('express').Application): cds_serve_fluent
+    with (impl: ServiceImpl | string): cds_serve_fluent
+    // (req,res) : void
+}
+
+export type cds_services = { [name: string]: Service }
+
+export type CdsFunction = {
+    (...args: any[]): any,
+    __parameters: object,
+    __returns: any,
+}
+
+namespace classes {
+    export {
         mixin,
         Protocol,
         Column,
@@ -282,6 +399,7 @@ declare namespace cds {
         any_,
         any,
         aspect,
+        type,
         scalar,
         boolean,
         Boolean_2 as Boolean,
@@ -306,52 +424,29 @@ declare namespace cds {
         Time,
         DateTime,
         TimeStamp,
+        array,
+        struct,
         context_,
         service_,
         action,
+        event,
+        entity,
+        Association,
+        Composition,
         ManagedAssociation,
         MixedIn
     }
 }
 
-export declare type _cds = typeof cds
-
-declare type _cds_2 = typeof cds
-
-export declare interface cds_connect_options {
-    impl?: string
-    service?: string
-    kind?: string
-    model?: string
-    credentials?: object
-}
-
-export declare interface cds_serve_fluent {
-    from (model: string | CSN_2): cds_serve_fluent
-    to (protocol: string): cds_serve_fluent
-    at (path: string): cds_serve_fluent
-    in (app: Application): cds_serve_fluent
-    with (impl: ServiceImpl | string): cds_serve_fluent
-    // (req,res) : void
-}
-
-export declare type cds_services = { [name: string]: Service }
-
-export declare type CdsFunction = {
-    (...args: any[]): any,
-    __parameters: object,
-    __returns: any,
-}
-
-export declare type Column = { ref: [string], as?: string }
+type Column = { ref: [string], as?: string }
 
-export declare type column_expr = UnionToIntersection<expr> & { as?: name, cast?: any, expand?: column_expr[], inline?: column_expr[] }
+export type column_expr = UnionToIntersection<expr> & { as?: name, cast?: any, expand?: column_expr[], inline?: column_expr[] }
 
 /**
  * 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.
  */
-export declare const compile: {
+export const compile: {
 
     /** Shortcut for `cds.compile.to.csn()` */
     cdl (model: CDL, o?: _options): csn.CSN,
@@ -433,11 +528,11 @@ export declare const compile: {
     },
 };
 
-export declare class Composition extends Association {
+export class Composition extends Association {
     isComposition: true
 }
 
-export declare const connect: {
+export const connect: {
 
     /**
      		 * Connects to a specific datasource.
@@ -459,11 +554,11 @@ export declare const connect: {
     (options?: string | cds_connect_options): Promise<_cds>, // > cds.connect(<options>)
 };
 
-declare interface Constructable<T = any> {
+interface Constructable<T = any> {
     new(...args: any[]): T
 }
 
-declare class ConstructedQuery {
+class ConstructedQuery {
 
     then (_resolved: (x: any) => any, _rejected: (e: Error) => any): any
 
@@ -472,15 +567,15 @@ declare class ConstructedQuery {
 /**
  * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx#event-contexts
  */
-export declare let context: EventContext | undefined;
+export let context: EventContext | undefined;
 
-export declare interface context_ extends csn.context {}
+interface context_ extends csn.context {}
 
-export declare class context_ extends any_ { }
+class context_ extends any_ { }
 
-declare interface context_2 extends any__2 { }
+interface context_2 extends any__2 { }
 
-declare namespace CQN {
+namespace CQN {
     export {
         Query,
         SELECT_2 as SELECT,
@@ -509,15 +604,15 @@ declare namespace CQN {
     }
 }
 
-export declare const create: Service['create'];
+export const create: Service['create'];
 
-declare type CREATE_2 = { CREATE: {
+type CREATE_2 = { CREATE: {
         entity: entity_2 | name,
         as: SELECT_2,
     }, }
 export { CREATE_2 as CREATE }
 
-declare class CREATE_3<T> extends ConstructedQuery {
+class CREATE_3<T> extends ConstructedQuery {
 
     static entity (entity: Target): CREATE_3<any>
 
@@ -525,116 +620,16 @@ declare class CREATE_3<T> extends ConstructedQuery {
 
 }
 
-export declare namespace CRUDEventHandler {
+export namespace CRUDEventHandler {
     export type Before<P, R = P | void | Error> = (req: TypedRequest<P>) => Promise<R> | R
     export type On<P, R = P | void | Error> = (req: TypedRequest<P>, next: (...args: any[]) => Promise<R> | R) => Promise<R> | R
     export type After<P, R = P | void | Error> = (data: undefined | P, req: TypedRequest<P>) => Promise<R> | R
 }
 
-export declare interface CSN extends Omit<csn.CSN, 'definitions'> {
-
-    /**
-     	 * Fetches definitions matching the given filter, returning an iterator on them.
-     	 * @example
-     	 * ```js
-     	 *   let m = cds.reflect (aParsedModel)
-     	 *   for (let d of m.each('entity'))  console.log (d.kind, d.name)
-     	 *   let entities = [...m.each('entity')]  //> capture all
-     	 *   let entities = m.all('entity')        //> equivalent shortcut
-     	 * ```
-     	 */
-    each<T extends any_>(x: Filter, defs?: Definitions<T>): IterableIterator<T>
-
-    /**
-     	 * Fetches definitions matching the given filter, returning them in an array.
-     	 * Convenience shortcut for `[...reflect.each('entity')]`
-     	 */
-    all<T extends any_>(x: Filter, defs?: Definitions<T>): T[]
-
-    /**
-     	 * Fetches definitions matching the given filter, returning the first match, if any.
-     	 * @example
-     	 *      let service = model.find('service')
-     	 * @param x - the filter
-     	 * @param defs - the definitions to fetch in, default: `this.definitions`
-     	 */
-    find<T extends any_>(x: Filter, defs?: Definitions<T>): T | undefined
-
-    /**
-     	 * Calls the visitor for each definition matching the given filter.
-     	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#foreach)
-     	 */
-    foreach(x: Filter, visitor: Visitor, defs?: Definitions): this
-    foreach(visitor: Visitor, defs?: Definitions): this
-
-    /**
-     	 * Same as foreach but recursively visits each element definition
-     	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#foreach)
-     	 */
-    forall(x: Filter, visitor: Visitor, defs?: Definitions): this
-    forall(visitor: Visitor, defs?: Definitions): this
-
-    /**
-     	 * Fetches definitions declared as children of a given parent context or service.
-     	 * It fetches all definitions whose fully-qualified names start with the parent's name.
-     	 * Returns the found definitions as an object with the local names as keys.
-     	 * @example
-     	 * ```js
-     	 *   let service  = model.find ('service')
-     	 *   let entities = m.childrenOf (service)
-     	 * ```
-     	 * @param parent - either the parent itself or its fully-qualified name
-     	 * @param filter - an optional filter to apply before picking a child
-     	 */
-    childrenOf(parent: any | string, filter?: ((def: any_) => boolean)): Definitions
-
-    /**
-     	 * Provides convenient access to the model's top-level definitions.
-     	 * For example, you can use it in an es6-import-like fashion to avoid
-     	 * working with fully-qualified names as follows:
-     	 *
-     	 * @example
-     	 * ```js
-     	 * let model = cds.reflect (cds.parse(`
-     	 *     namespace our.lovely.bookshop;
-     	 *     entity Books {...}
-     	 *     entity Authors {...}
-     	 * `))
-     	 * const {Books,Authors} = model.exports
-     	 * SELECT.from (Books) .where ({ID:11})
-     	 * ```
-     	 */
-    exports: IterableMap<any_>
-    definitions: IterableMap<any_>
-    entities: ModelPart<entity>
-    services: ModelPart<service_>
-
-}
-
-declare namespace csn {
-    export {
-        CSN_2 as CSN,
-        FQN,
-        Definition_2 as Definition,
-        Extension,
-        Element,
-        kinds,
-        any__2 as any_,
-        context_2 as context,
-        service_2 as service,
-        type_2 as type,
-        struct_2 as struct,
-        entity_2 as entity,
-        EntityElements,
-        Association_2 as Association
-    }
-}
-export { csn }
-
 /**
  * A parsed CDS model in CSN object notation.
  */
-declare interface CSN_2 {
+interface CSN {
 
     /**
      * The assigned namespace. If parsed from multiple sources,
@@ -652,7 +647,7 @@ declare interface CSN_2 {
     /**
      * All definitions in the model including those from imported models.
      */
-    definitions?: Record<FQN, Definition_2>
+    definitions?: Record<FQN, Definition>
 
     /**
      * All extensions in the model including those from imported models.
@@ -666,17 +661,37 @@ declare interface CSN_2 {
     $sources?: string[]
 }
 
+namespace csn {
+    export {
+        CSN,
+        FQN,
+        Definition,
+        Extension,
+        Element,
+        kinds,
+        any__2 as any_,
+        context_2 as context,
+        service_2 as service,
+        type_2 as type,
+        struct_2 as struct,
+        entity_2 as entity,
+        EntityElements,
+        Association_2 as Association
+    }
+}
+export { csn }
+
 /** @private */
-export declare type data = Record<string, any>
+export type data = Record<string, any>
 
-export declare class DatabaseService extends Service {
+export class DatabaseService extends Service {
     deploy (model?: csn.CSN | string): Promise<csn.CSN>
     begin (): Promise<void>
     commit (): Promise<void>
     rollback (): Promise<void>
 }
 
-declare class DataUtil {
+class DataUtil {
 
     delete (db?: Service): Promise<void>
 
@@ -689,14 +704,13 @@ declare class DataUtil {
 
 }
 
-export declare class date extends scalar { }
+class date extends scalar { }
 
-declare class Date_2 extends date { }
-export { Date_2 as Date }
+class Date_2 extends date { }
 
-export declare class DateTime extends date { }
+class DateTime extends date { }
 
-export declare const db: DatabaseService;
+export const db: DatabaseService;
 
 /**
  * Shortcut to `cds.log(...).debug`, returning `undefined` if `cds.log(...)._debug` is `false`.
@@ -710,32 +724,32 @@ export declare const db: DatabaseService;
  *
  * @param name - logger name
  */
-export declare function debug (name: string): undefined | Log
-
-export declare class Decimal extends Float { }
+export function debug (name: string): undefined | Log
 
-export declare type Definition = any_
+class Decimal extends Float { }
 
 /**
  * Definitions are the central elements of a CDS model.
  */
-declare type Definition_2 = context_2 & service_2 & type_2 & struct_2 & entity_2 & Association_2
+type Definition = context_2 & service_2 & type_2 & struct_2 & entity_2 & Association_2
+
+type Definition_2 = any_
 
 /**
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
  */
-export declare type Definitions<T extends any_ = any_> = IterableMap<T>
+type Definitions<T extends any_ = any_> = IterableMap<T>
 
-declare const delete_: Service['delete'];
+const delete_: Service['delete'];
 export { delete_ as delete };
 
-declare type DELETE_2 = { DELETE: {
+type DELETE_2 = { DELETE: {
         from: ref | name,
         where?: predicate,
     }, }
 export { DELETE_2 as DELETE }
 
-declare class DELETE_3<T> extends ConstructedQuery {
+class DELETE_3<T> extends ConstructedQuery {
 
     static from:
     TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
@@ -755,16 +769,16 @@ declare class DELETE_3<T> extends ConstructedQuery {
 
 }
 
-export declare class Double extends Float { }
+class Double extends Float { }
 
-declare type DROP_2 = { DROP: {
+type DROP_2 = { DROP: {
         entity: name,
         table: ref,
         view: ref,
     }, }
 export { DROP_2 as DROP }
 
-declare class DROP_3<T> extends ConstructedQuery {
+class DROP_3<T> extends ConstructedQuery {
 
     static entity (entity: Target): DROP_3<any>
 
@@ -772,20 +786,20 @@ declare class DROP_3<T> extends ConstructedQuery {
 
 }
 
-export declare type EDM = { $version: string }
+export type EDM = { $version: string }
 
-export declare type EDMX = XML
+export type EDMX = XML
 
-declare type Element = type_2 & struct_2 & Association_2
+type Element = type_2 & struct_2 & Association_2
 
-export declare const entities: Service['entities'];
+export const entities: Service['entities'];
 
 /**
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-entity)
  */
-export declare interface entity extends Omit<csn.entity, 'elements' | 'items' | 'keys' | 'drafts'> {}
+export interface entity extends Omit<csn.entity, 'elements' | 'items' | 'keys' | 'drafts'> {}
 
-export declare class entity extends struct<'entity'> {
+export class entity extends struct<'entity'> {
     is_entity: true
 
     keys: Definitions<type>
@@ -801,7 +815,7 @@ export declare class entity extends struct<'entity'> {
     drafts?: entity
 }
 
-declare interface entity_2 extends Omit<struct_2, 'elements'> {
+interface entity_2 extends Omit<struct_2, 'elements'> {
 
     /**
      * Entities with a query signify a view
@@ -813,11 +827,11 @@ declare interface entity_2 extends Omit<struct_2, 'elements'> {
      */
     elements: EntityElements
     // REVISIT: following should move to LinkedCSN
-    keys: { [name: string]: Definition_2 }
+    keys: { [name: string]: Definition }
     drafts?: entity_2
 }
 
-declare type EntityElements = {
+type EntityElements = {
     [name: string]: Element & {
         key?: boolean,
         virtual?: boolean,
@@ -826,7 +840,7 @@ declare type EntityElements = {
     },
 }
 
-export declare type enum_literal = { '#': string }
+export type enum_literal = { '#': string }
 
 /**
  * Access to the configuration for Node.js runtime and tools.
@@ -834,7 +848,7 @@ export declare type enum_literal = { '#': string }
  * filtered through the currently active profiles, thus highly dependent on the current working
  * directory and process environment.
  */
-export declare const env: {
+export const env: {
     build: _TODO,
     hana: _TODO,
     i18n: {
@@ -856,7 +870,7 @@ export declare const env: {
     sql: _TODO,
 } & { [key: string]: any };
 
-export declare namespace env {
+export namespace env {
 
     export interface MockUser {
         tenant?: string
@@ -934,12 +948,12 @@ export declare namespace env {
     }
 }
 
-export declare class event extends aspect<'event'> {}
+export class event extends aspect<'event'> {}
 
 /**
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/events)
  */
-declare class Event_2 extends EventContext {
+class Event_2 extends EventContext {
 
     event: string
 
@@ -954,10 +968,10 @@ export { Event_2 as Event }
  * Represents the invocation context of incoming request and event messages.
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/events)
  */
-export declare class EventContext {
+export class EventContext {
 
     constructor (properties: { event: string, data?: object, query?: object, headers?: object })
-    http?: { req: express.Request, res: express.Response }
+    http?: { req: import('express').Request, res: import('express').Response }
 
     tenant: string
 
@@ -973,7 +987,7 @@ export declare class EventContext {
 
 }
 
-export declare interface EventHandler {
+export interface EventHandler {
     // (msg : types.EventMessage) : Promise<any> | any | void
     (req: Request_2): Promise<any> | any | void
 }
@@ -982,11 +996,11 @@ export declare interface EventHandler {
  * Provides a graceful shutdown for running servers, by first emitting `cds.emit('shutdown')`.
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-facade#cds-exit)
  */
-export declare function exit (): void
+export function exit (): void
 
-export declare type expr = ref | val | xpr | function_call | SELECT_2
+export type expr = ref | val | xpr | function_call | SELECT_2
 
-export declare type expr_literal = { '=': string }
+export type expr_literal = { '=': string }
 
 /**
  * Add aspects to a given object, for example:
@@ -999,30 +1013,30 @@ export declare type expr_literal = { '=': string }
  *    }.prototype)
  * ```
  */
-export declare function extend<T> (target: T): {
+export function extend<T> (target: T): {
     with<E extends readonly any[]>(...ext: E): T & Intersect<E>,
 }
 
 /**
  * Extensions capture `extend Foo with { ... }` directives.
  */
-declare type Extension = {
+type Extension = {
     extend: FQN,
     elements?: { [name: string]: Element },
     includes?: FQN[],
 }
 
-export declare type filename = string
+export type filename = string
 
-declare type Filter = string | (<T extends any_ = any_>(def: T) => boolean)
+type Filter = string | (<T extends any_ = any_>(def: T) => boolean)
 
-export declare type _flavor = 'parsed' | 'xtended' | 'inferred'
+export type _flavor = 'parsed' | 'xtended' | 'inferred'
 
-export declare class Float extends number { }
+class Float extends number { }
 
-export declare const foreach: Service['foreach'];
+export const foreach: Service['foreach'];
 
-declare type Formatter = {
+type Formatter = {
 
     /**
      * Custom format function
@@ -1038,10 +1052,10 @@ declare type Formatter = {
 /**
  * The fully-quality name of a definition.
  */
-declare type FQN = string
+type FQN = string
 
 /** @private */
-export declare type function_call = { func: string, args: { [key: string]: any }[] }
+export type function_call = { func: string, args: { [key: string]: any }[] }
 
 /**
  * Loads and parses models from the specified files.
@@ -1049,13 +1063,13 @@ export declare type function_call = { func: string, args: { [key: string]: any }
  * Essentially a shortcut for `cds.compile.to.csn(files)`
  * @param files - filenames of models or if folder containing models
  */
-export declare function get (files: '*' | filename | filename[], o?: _options): Promise<csn.CSN>
+export function get (files: '*' | filename | filename[], o?: _options): Promise<csn.CSN>
 
-export declare const home: string;
+export const home: string;
 
-export declare const insert: Service['insert'];
+export const insert: Service['insert'];
 
-declare type INSERT_2 = { INSERT: {
+type INSERT_2 = { INSERT: {
         into: ref | name,
         entries: data[],
         columns: string[],
@@ -1065,7 +1079,7 @@ declare type INSERT_2 = { INSERT: {
     }, }
 export { INSERT_2 as INSERT }
 
-declare class INSERT_3<T> extends ConstructedQuery {
+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>>)
@@ -1094,15 +1108,15 @@ declare class INSERT_3<T> extends ConstructedQuery {
 
 }
 
-export declare class Int16 extends Integer { }
+class Int16 extends Integer { }
 
-export declare class Int32 extends Integer { }
+class Int32 extends Integer { }
 
-export declare class Int64 extends Integer { }
+class Int64 extends Integer { }
 
-export declare class Integer extends number { }
+class Integer extends number { }
 
-declare type Intersect<T extends readonly unknown[]> = T extends [infer Head, ...infer Tail]
+type Intersect<T extends readonly unknown[]> = T extends [infer Head, ...infer Tail]
 ? Head & Intersect<Tail>
 : unknown
 
@@ -1110,18 +1124,18 @@ declare type Intersect<T extends readonly unknown[]> = T extends [infer Head, ..
  * Object structure that exposes both array-like and object-like behaviour.
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
  */
-declare type IterableMap<T> = { [name: string]: T } & _ArrayLike<T>
+type IterableMap<T> = { [name: string]: T } & _ArrayLike<T>
 
-declare type JSON_2 = string
+type JSON_2 = string
 export { JSON_2 as JSON }
 
-export declare type Key = number | string | any
+export type Key = number | string | any
 
-declare type kinds = 'aspect' | 'entity' | 'type' | 'event' | 'action' | 'function' | 'service' | 'context' | 'elements'
+type kinds = 'aspect' | 'entity' | 'type' | 'event' | 'action' | 'function' | 'service' | 'context' | 'elements'
 
-export declare class LargeBinary extends Binary { }
+class LargeBinary extends Binary { }
 
-export declare class LargeString extends String_2 { }
+class LargeString extends String_2 { }
 
 /**
  * Prepare a node module for lazy-loading submodules instead
@@ -1138,7 +1152,7 @@ export declare class LargeString extends String_2 { }
  * The first usage of `facade.sub` will load the sub module
  * using standard Node.js's `module.require` functions.
  */
-export declare function lazified<T> (target: T): T
+export function lazified<T> (target: T): T
 
 /**
  * Equip a given facade object with getters for lazy-loading modules instead
@@ -1154,137 +1168,185 @@ export declare function lazified<T> (target: T): T
  * The first usage of `facade.sub` will load the sub module
  * using standard Node.js's `module.require` functions.
  */
-export declare function lazify<T> (target: T): T
+export function lazify<T> (target: T): T
 
-declare enum levels {
+enum levels {
     // SILLY and VERBOSE are aliases for TRACE
     /* eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values */
     SILENT = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4, TRACE = 5, SILLY = 5, VERBOSE = 5
 }
 
-export declare const linked: {
+export const linked: {
 
     /**
      * Turns the given plain CSN model into a linked model
      * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect)
      */
-    (model: csn.CSN): linked_2.CSN,
+    (model: csn.CSN): linked_2.LinkedCSN,
 
     /**
      * Base classes of linked definitions from reflected models.
      * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-builtin-classes)
      */
-    classes: typeof LinkedClasses,
+    classes: typeof classes,
+
+    /**
+     * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#linked-csn)
+     */
+    LinkedCSN: linked_2.LinkedCSN,
+
+    /**
+     * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
+     */
+    LinkedDefinitions: IterableMap<linked_2.classes.any_>,
 };
 
-declare namespace linked_2 {
-    export {
-        ModelPart,
-        Definition,
-        CSN,
-        mixin,
-        Protocol,
-        Column,
-        Definitions,
-        WithElements,
-        any_,
-        any,
-        aspect,
-        type,
-        scalar,
-        boolean,
-        Boolean_2 as Boolean,
-        string,
-        UUID,
-        String_2 as String,
-        LargeString,
-        Binary,
-        LargeBinary,
-        Vector,
-        number,
-        Integer,
-        UInt8,
-        Int16,
-        Int32,
-        Int64,
-        Float,
-        Double,
-        Decimal,
-        date,
-        Date_2 as Date,
-        Time,
-        DateTime,
-        TimeStamp,
-        array,
-        struct,
-        context_,
-        service_,
-        action,
-        event,
-        entity,
-        Association,
-        Composition,
-        ManagedAssociation,
-        MixedIn
+export namespace linked {
+    export type LinkedDefinitions = IterableMap<linked_2.classes.any_>
+    export type LinkedCSN = linked_2.LinkedCSN
+
+    export namespace classes {
+        export type type = __type
+        export type aspect = __aspect
+
+        export type any_ = __any_
+
+        export type scalar = __scalar
+        // can not shadow builtins. Same for string and number...
+        //export type boolean = LinkedClasses.Boolean  // on purpose
+        export type Boolean = __Boolean
+
+        export type UUID = __UUID
+        //export type string = LinkedClasses.String  // on purpose
+        export type String = __String
+        export type LargeString = __LargeString
+        export type Binary = __Binary
+        export type LargeBinary = __LargeBinary
+        export type Vector = __Vector
+
+        //export type number = LinkedClasses.scalar  // currently no better way to do this
+        export type Integer = __Integer
+        export type UInt8 = __UInt8
+        export type Int16 = __Int16
+        export type Int32 = __Int32
+        export type Int64 = __Int64
+        export type Float = __Float
+        export type Double = __Double
+        export type Decimal = __Decimal
+
+        export type date = __date
+        export type Date = __Date
+        export type Time = __Time
+        export type DateTime = __DateTime
+        export type TimeStamp = __TimeStamp
+
+        export type array = __array
+
+        export type struct = __struct
+        export type context_ = __context_
+        export type service = __service
+        export type entity = __entity
+        export type Association = __Association
+        export type Composition = __Composition
     }
 }
 
-declare namespace LinkedClasses {
+namespace linked_2 {
     export {
-        mixin,
-        Protocol,
-        Column,
-        Definitions,
-        WithElements,
-        any_,
-        any,
-        aspect,
-        type,
-        scalar,
-        boolean,
-        Boolean_2 as Boolean,
-        string,
-        UUID,
-        String_2 as String,
-        LargeString,
-        Binary,
-        LargeBinary,
-        Vector,
-        number,
-        Integer,
-        UInt8,
-        Int16,
-        Int32,
-        Int64,
-        Float,
-        Double,
-        Decimal,
-        date,
-        Date_2 as Date,
-        Time,
-        DateTime,
-        TimeStamp,
-        array,
-        struct,
-        context_,
-        service_,
-        action,
-        event,
-        entity,
-        Association,
-        Composition,
-        ManagedAssociation,
-        MixedIn
+        ModelPart,
+        Definition_2 as Definition,
+        LinkedCSN,
+        classes
     }
 }
 
+interface LinkedCSN extends Omit<csn.CSN, 'definitions'> {
+
+    /**
+     	 * Fetches definitions matching the given filter, returning an iterator on them.
+     	 * @example
+     	 * ```js
+     	 *   let m = cds.reflect (aParsedModel)
+     	 *   for (let d of m.each('entity'))  console.log (d.kind, d.name)
+     	 *   let entities = [...m.each('entity')]  //> capture all
+     	 *   let entities = m.all('entity')        //> equivalent shortcut
+     	 * ```
+     	 */
+    each<T extends any_>(x: Filter, defs?: Definitions<T>): IterableIterator<T>
+
+    /**
+     	 * Fetches definitions matching the given filter, returning them in an array.
+     	 * Convenience shortcut for `[...reflect.each('entity')]`
+     	 */
+    all<T extends any_>(x: Filter, defs?: Definitions<T>): T[]
+
+    /**
+     	 * Fetches definitions matching the given filter, returning the first match, if any.
+     	 * @example
+     	 *      let service = model.find('service')
+     	 * @param x - the filter
+     	 * @param defs - the definitions to fetch in, default: `this.definitions`
+     	 */
+    find<T extends any_>(x: Filter, defs?: Definitions<T>): T | undefined
+
+    /**
+     	 * Calls the visitor for each definition matching the given filter.
+     	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#foreach)
+     	 */
+    foreach(x: Filter, visitor: Visitor, defs?: Definitions): this
+    foreach(visitor: Visitor, defs?: Definitions): this
+
+    /**
+     	 * Same as foreach but recursively visits each element definition
+     	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#foreach)
+     	 */
+    forall(x: Filter, visitor: Visitor, defs?: Definitions): this
+    forall(visitor: Visitor, defs?: Definitions): this
+
+    /**
+     	 * Fetches definitions declared as children of a given parent context or service.
+     	 * It fetches all definitions whose fully-qualified names start with the parent's name.
+     	 * Returns the found definitions as an object with the local names as keys.
+     	 * @example
+     	 * ```js
+     	 *   let service  = model.find ('service')
+     	 *   let entities = m.childrenOf (service)
+     	 * ```
+     	 * @param parent - either the parent itself or its fully-qualified name
+     	 * @param filter - an optional filter to apply before picking a child
+     	 */
+    childrenOf(parent: any | string, filter?: ((def: any_) => boolean)): Definitions
+
+    /**
+     	 * Provides convenient access to the model's top-level definitions.
+     	 * For example, you can use it in an es6-import-like fashion to avoid
+     	 * working with fully-qualified names as follows:
+     	 *
+     	 * @example
+     	 * ```js
+     	 * let model = cds.reflect (cds.parse(`
+     	 *     namespace our.lovely.bookshop;
+     	 *     entity Books {...}
+     	 *     entity Authors {...}
+     	 * `))
+     	 * const {Books,Authors} = model.exports
+     	 * SELECT.from (Books) .where ({ID:11})
+     	 * ```
+     	 */
+    exports: IterableMap<any_>
+    definitions: IterableMap<any_>
+    entities: ModelPart<entity>
+    services: ModelPart<service_>
+
+}
+
 /**
  * Shortcut for `cds.get(files, 'inferred')`
  * @param files - filenames of models or if folder containing models
  */
-export declare function load (files: '*' | filename | filename[], o?: _options): Promise<csn.CSN>
+export function load (files: '*' | filename | filename[], o?: _options): Promise<csn.CSN>
 
-declare type Log = {
+type Log = {
 
     /**
      * Logs a message
@@ -1298,9 +1360,9 @@ declare type Log = {
 /**
  * Create a new logger, or install a custom log formatter
  */
-export declare const log: LogFactory;
+export const log: LogFactory;
 
-declare type LogFactory = {
+type LogFactory = {
 
     /**
      * Returns a trace logger for the given module if trace is switched on for it,
@@ -1354,7 +1416,7 @@ declare type LogFactory = {
     winstonLogger (LoggerOptions?: { level?: string, levels?: any, format?: any, transports?: any, exitOnError?: boolean | Function, silent?: boolean }),
 }
 
-declare class Logger {
+class Logger {
 
 
     /**
@@ -1424,19 +1486,19 @@ declare class Logger {
 
 }
 
-declare type LogLevel = keyof typeof levels | Lowercase<keyof typeof levels> | levels
+type LogLevel = keyof typeof levels | Lowercase<keyof typeof levels> | levels
 
-export declare type ManagedAssociation = Association & {
+type ManagedAssociation = Association & {
     foreignKeys: Definitions<type>,
     keys: Column[],
 }
 
-export declare class MessagingService extends Service {}
+export class MessagingService extends Service {}
 
-export declare type Middleswares = 'context' | 'trace' | 'auth' | 'ctx_model' | string
+export type Middleswares = 'context' | 'trace' | 'auth' | 'ctx_model' | string
 
-export declare const middlewares: {
-    add: (middleware: RequestHandler, pos?: XOR<XOR<{ at: number }, { after: Middleswares }>, { before: Middleswares }>) => void,
+export const middlewares: {
+    add: (middleware: import('express').RequestHandler, pos?: XOR<XOR<{ at: number }, { after: Middleswares }>, { before: Middleswares }>) => void,
 };
 
 /**
@@ -1459,7 +1521,7 @@ export declare const middlewares: {
  * s2.bar  // error :)
  * ```
  */
-export declare type MixedIn<T> = T & { [key: string | number | symbol]: unknown }
+type MixedIn<T> = T & { [key: string | number | symbol]: unknown }
 
 /**
  * Using this will require you to explicitly cast all classes you added mixins to
@@ -1467,18 +1529,18 @@ export declare type MixedIn<T> = T & { [key: string | number | symbol]: unknown
  * properties, you can use the {@link MixedIn} type.
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#mixin)
  */
-export declare function mixin (...classes: (new () => any)[]): void
+function mixin (...classes: (new () => any)[]): void
 
 /**
  * The effective CDS model loaded during bootstrapping, which contains all service and entity definitions,
  * including required services.
  * Should only be ever set explictly in test scenarios!
  */
-export declare let model: linked_2.CSN | undefined;
+export let model: linked_2.LinkedCSN | undefined;
 
-export declare type ModelPart<T extends any_> = IterableMap<T> & ((namespace: string) => IterableMap<T>)
+type ModelPart<T extends any_> = IterableMap<T> & ((namespace: string) => IterableMap<T>)
 
-declare namespace models {
+namespace models {
     export {
         get,
         load,
@@ -1498,18 +1560,49 @@ declare namespace models {
         model,
         parse,
         linked,
+        __type,
+        __aspect,
+        __any_,
+        __scalar,
+        __Boolean,
+        __UUID,
+        __String,
+        __LargeString,
+        __Binary,
+        __LargeBinary,
+        __Vector,
+        __Integer,
+        __UInt8,
+        __Int16,
+        __Int32,
+        __Int64,
+        __Float,
+        __Double,
+        __Decimal,
+        __date,
+        __Date,
+        __Time,
+        __DateTime,
+        __TimeStamp,
+        __array,
+        __struct,
+        __context_,
+        __service,
+        __entity,
+        __Association,
+        __Composition,
         compile
     }
 }
 
 /** @private */
-export declare type name = string
+export type name = string
 
-export declare const number: typeof number_;
+const number: typeof number_;
 
-declare class number_ extends scalar { }
+class number_ extends scalar { }
 
-export declare type _odata_options = {
+export type _odata_options = {
     flavor?: 'v2' | 'v4' | 'w4' | 'x4',
     version?: 'v2' | 'v4',
     structs?: boolean,
@@ -1521,65 +1614,65 @@ export declare type _odata_options = {
  	 */
 // FIXME: this is actually supposed to be part of models.d.ts
 // but had to be moved here so export * would not clash their definitions
-export declare function on (event: 'loaded', listener: (model: CSN_2) => void): _cds
+export function on (event: 'loaded', listener: (model: CSN) => void): _cds
 
 /**
  	 * Emitted whenever a specific service is connected for the first time.
  	 */
-export declare function on (event: 'connect', listener: (srv: Service) => void): _cds
+export function on (event: 'connect', listener: (srv: Service) => void): _cds
 
 /**
  	 * Emitted at the very beginning of the bootsrapping process, when the
  	 * express application has been constructed but no middlewares or routes
  	 * added yet.
  	 */
-export declare function on (event: 'bootstrap', listener: (app: Application) => void): _cds
+export function on (event: 'bootstrap', listener: (app: import('express').Application) => void): _cds
 
 /**
  	 * Emitted for each service served by cds.serve().
  	 */
-export declare function on (event: 'serving', listener: (srv: Service) => void): _cds
+export function on (event: 'serving', listener: (srv: Service) => void): _cds
 
 /**
  	 * Emitted by the default, built-in `server.js` when all services are
  	 * constructed and mounted by cds.serve().
  	 */
-export declare function on (event: 'served', listener: (all: cds_services) => void): _cds
+export function on (event: 'served', listener: (all: cds_services) => void): _cds
 
 /**
  	 * Emitted by the default, built-in `server.js` when the http server
  	 * is started and listening for incoming requests.
  	 */
-export declare function on (event: 'listening', listener: (args: { server: http.Server, url: string }) => void): _cds
+export function on (event: 'listening', listener: (args: { server: import('http').Server, url: string }) => void): _cds
 
 /**
  	 * Emitted by the default, built-in `server.js` when the http server
  	 * is shutdown.
  	 */
-export declare function on (event: 'shutdown', listener: () => void): _cds
+export function on (event: 'shutdown', listener: () => void): _cds
 
-export declare function once (event: 'bootstrap', listener: (app: Application) => void): _cds
+export function once (event: 'bootstrap', listener: (app: import('express').Application) => void): _cds
 
-export declare function once (event: 'served', listener: (all: cds_services) => void): _cds
+export function once (event: 'served', listener: (all: cds_services) => void): _cds
 
-export declare function once (event: 'listening', listener: (args: { server: http.Server, url: string }) => void): _cds
+export function once (event: 'listening', listener: (args: { server: import('http').Server, url: string }) => void): _cds
 
-export declare function once (event: 'shutdown', listener: () => void): _cds
+export function once (event: 'shutdown', listener: () => void): _cds
 
-export declare type OneOrMany<T> = T | T[]
+export type OneOrMany<T> = T | T[]
 
-export declare interface OnErrorHandler {
+export interface OnErrorHandler {
     (err: Error, req: Request_2): any | void
 }
 
-export declare interface OnEventHandler {
+export interface OnEventHandler {
     (req: Request_2, next: Function): Promise<any> | any | void
 }
 
 /** @private */
-export declare type operator = string
+export type operator = string
 
-export declare type _options = {
+export type _options = {
     flavor?: _flavor,
     plain?: boolean,
     docs?: boolean,
@@ -1588,15 +1681,15 @@ export declare type _options = {
 } | _flavor
 
 /** @private */
-export declare type ordering_term = expr & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
+export type ordering_term = expr & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
 
-export declare const outboxed: (service: Service) => Service;
+export const outboxed: (service: Service) => Service;
 
 /**
  * Provides a set of methods to parse a given model, query or expression.
  * You can also use `cds.parse()` as a shortcut to `cds.parse.cdl()`.
  */
-export declare const parse: {
+export const parse: {
 
     /** Shortcut to `cds.parse.cdl()` */
     (cdl: CDL): csn.CSN,
@@ -1607,24 +1700,24 @@ export declare const parse: {
     ref (src: string): string[],
 };
 
-declare type Partial_2<T> = { [Key in keyof T]: undefined | T[Key] }
+type Partial_2<T> = { [Key in keyof T]: undefined | T[Key] }
 export { Partial_2 as Partial }
 
-declare type PK = number | string | object
+type PK = number | string | object
 
-declare type PluralType<T extends Constructable> = Array<InstanceType<T>>
+type PluralType<T extends Constructable> = Array<InstanceType<T>>
 
-export declare type predicate = UnionsToIntersections<_xpr>
+export type predicate = UnionsToIntersections<_xpr>
 
-declare type Primitive = string | number | boolean | Date
+type Primitive = string | number | boolean | Date
 
 /** @private */
-export declare type primitive = number | string | boolean | null
+export type primitive = number | string | boolean | null
 
 /**
  * Subclass for executing code with superuser privileges.
  */
-export declare class Privileged extends User {
+export class Privileged extends User {
 
     constructor ()
 
@@ -1632,15 +1725,15 @@ export declare class Privileged extends User {
 
 }
 
-declare type Projection<T> = (e: QLExtensions<T extends ArrayConstructable ? SingularType<T> : T>) => void
+type Projection<T> = (e: QLExtensions<T extends ArrayConstructable ? SingularType<T> : T>) => void
 
 /**
  * @alpha
  * related to .protocols getters
  */
-export declare type Protocol = 'odata' | 'rest'
+type Protocol = 'odata' | 'rest'
 
-declare class QL<T> {
+class QL<T> {
 
     SELECT: StaticSELECT<T>
 
@@ -1662,7 +1755,7 @@ declare class QL<T> {
 
 }
 
-declare namespace ql {
+namespace ql {
     export {
         Query_2 as Query,
         ConstructedQuery,
@@ -1690,13 +1783,13 @@ declare namespace ql {
 }
 export { ql }
 
-export declare type QLExtensions<T> = T extends QLExtensions_<any> ? T : QLExtensions_<T>
+export type QLExtensions<T> = T extends QLExtensions_<any> ? T : QLExtensions_<T>
 
 /**
  * QLExtensions are properties that are attached to entities in CQL contexts.
  * They are passed down to all properties recursively.
  */
-declare type QLExtensions_<T> = {
+type QLExtensions_<T> = {
     [Key in keyof T]: QLExtensions<T[Key]>
 } & {
 
@@ -1718,13 +1811,13 @@ declare type QLExtensions_<T> = {
     // over T and undefined, which gives us zero code completion within the callable.
 } & Subqueryable<Exclude<T, undefined>>
 
-export declare type Query = Partial<SELECT_2 & INSERT_2 & UPDATE_2 & DELETE_2 & CREATE_2 & DROP_2 & UPSERT_2>
+export type Query = Partial<SELECT_2 & INSERT_2 & UPDATE_2 & DELETE_2 & CREATE_2 & DROP_2 & UPSERT_2>
 
-declare type Query_2 = CQN.Query
+type Query_2 = CQN.Query
 
-export declare class QueryAPI {
+export class QueryAPI {
 
-    entities: linked_2.CSN['entities']
+    entities: linked_2.LinkedCSN['entities']
 
     /**
      * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
@@ -1781,10 +1874,10 @@ export declare class QueryAPI {
     stream: {
         (column: string): {
             from(entity: linked_2.Definition | string): {
-                where(filter: any): ReadableStream,
+                where(filter: any): import('node:stream/web').ReadableStream,
             },
         },
-        (query: Query_2): Promise<ReadableStream>,
+        (query: Query_2): Promise<import('node:stream/web').ReadableStream>,
     }
 
     /**
@@ -1810,23 +1903,23 @@ export declare class QueryAPI {
 
 }
 
-export declare const read: Service['read'];
+export const read: Service['read'];
 
 /** @private */
-export declare type ref = { ref: (name & { id?: string, where?: expr, args?: expr[] })[] }
+export type ref = { ref: (name & { id?: string, where?: expr, args?: expr[] })[] }
 
 /**
  * Turns the given plain CSN model into a reflected model
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect)
  */
-export declare function reflect (model: csn.CSN): linked_2.CSN
+export function reflect (model: csn.CSN): linked_2.LinkedCSN
 
-export declare class RemoteService extends Service {}
+export class RemoteService extends Service {}
 
 /**
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/events)
  */
-declare class Request_2 extends Event_2 {
+class Request_2 extends Event_2 {
 
     params: (string | object)[]
 
@@ -1834,7 +1927,7 @@ declare class Request_2 extends Event_2 {
 
     path: string
 
-    target: Definition
+    target: Definition_2
 
     /**
      * Shortcut to {@link Request.target | target (entity) name}
@@ -1891,7 +1984,7 @@ declare class Request_2 extends Event_2 {
 }
 export { Request_2 as Request }
 
-export declare const requires: env.Requires;
+export const requires: env.Requires;
 
 /**
  * Resolves given file or module name(s) to an array of absolute file names.
@@ -1901,24 +1994,24 @@ export declare const requires: env.Requires;
  * @param files - The file or module name(s) of a model or a folder containing models. Specify `'*'` to fetch moels from default locations, i.e. `[ 'db/', 'srv/', 'app/' ]`
  * @returns An array of absolute file names or `undefined` if none could be resolved.
  */
-export declare function resolve (files: '*' | filename | filename[]): filename[] | undefined
+export function resolve (files: '*' | filename | filename[]): filename[] | undefined
 
-export declare interface ResultSet extends Array<object> {}
+export interface ResultSet extends Array<object> {}
 
-export declare interface ResultsHandler {
+export interface ResultsHandler {
     (results: any[], req: Request_2): void
     (each: any, req: Request_2): void
 }
 
-export declare const root: string;
+export const root: string;
 
-export declare const run: Service['run'];
+export const run: Service['run'];
 
-export declare class scalar extends type { }
+class scalar extends type { }
 
-declare type Scalarise<A> = A extends Array<infer N> ? N : A
+type Scalarise<A> = A extends Array<infer N> ? N : A
 
-declare type SELECT_2 = { SELECT: {
+type SELECT_2 = { SELECT: {
         distinct?: true,
         one?: boolean,
         from: source,
@@ -1933,7 +2026,7 @@ declare type SELECT_2 = { SELECT: {
     }, }
 export { SELECT_2 as SELECT }
 
-declare class SELECT_3<T> extends ConstructedQuery {
+class SELECT_3<T> extends ConstructedQuery {
 
     static one: SELECT_one & { from: SELECT_one }
 
@@ -1999,7 +2092,7 @@ declare class SELECT_3<T> extends ConstructedQuery {
 
 }
 
-declare type SELECT_from =
+type SELECT_from =
 // tagged template
 TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
 &
@@ -2029,7 +2122,7 @@ primaryKey: PK,
 projection?: Projection<InstanceType<T>>
 ) => Awaitable<SELECT_3<PluralType<T>>, PluralType<T>>)
 
-declare type SELECT_one =
+type SELECT_one =
 TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
 &
 // calling with class
@@ -2052,7 +2145,7 @@ TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
  	 * Constructs service providers from respective service definitions
  	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-serve)
  	 */
-export declare const serve: (service: string, options?: {
+export const serve: (service: string, options?: {
     service?: string,
     from?: '*' | 'all' | string,
     [key: string]: any,
@@ -2061,13 +2154,13 @@ export declare const serve: (service: string, options?: {
 /**
  	 * The default bootstrap function as loaded from server.js
  	 */
-export declare const server: Function;
+export const server: Function;
 
 /**
  * Class cds.Service
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
  */
-export declare class Service extends QueryAPI {
+export class Service extends QueryAPI {
 
     constructor (
     name?: string,
@@ -2092,31 +2185,31 @@ export declare class Service extends QueryAPI {
      * The model from which the service's definition was loaded
      * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
      */
-    model: linked_2.CSN
+    model: linked_2.LinkedCSN
 
     /**
      * Provides access to the entities exposed by a service
      * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
      */
-    entities: linked_2.ModelPart<linked_2.entity>
+    entities: linked_2.ModelPart<linked_2.classes.entity>
 
     /**
      * Provides access to the events declared by a service
      * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
      */
-    events: linked_2.ModelPart<linked_2.event>
+    events: linked_2.ModelPart<linked_2.classes.event>
 
     /**
      * Provides access to the types exposed by a service
      * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
      */
-    types: linked_2.ModelPart<linked_2.type>
+    types: linked_2.ModelPart<linked_2.classes.type>
 
     /**
      * Provides access to the operations, i.e. actions and functions, exposed by a service
      * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
      */
-    operations: linked_2.ModelPart<linked_2.action>
+    operations: linked_2.ModelPart<linked_2.classes.action>
 
     /**
      * Acts like a parameter-less constructor. Ensure to call `await super.init()` to have the base class’s handlers added.
@@ -2226,9 +2319,9 @@ export declare class Service extends QueryAPI {
  	 * Shortcut to base class for all service definitions from linked models.
  	 * Plus accessors to impl functions and constructed providers.
  	 */
-export declare const service: service;
+export const service: service;
 
-export declare type service = {
+export type service = {
 
     /**
      	 * Dummy wrapper for service implementation functions.
@@ -2246,9 +2339,9 @@ export declare type service = {
 /**
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-service)
  */
-export declare interface service_ extends csn.service {}
+interface service_ extends csn.service {}
 
-export declare class service_ extends context_ {
+class service_ extends context_ {
     is_service: true
     get entities (): Definitions<entity>
     get types (): Definitions<type>
@@ -2267,28 +2360,28 @@ export declare class service_ extends context_ {
     get protocols (): { [protocol in Protocol]?: boolean | undefined }
 }
 
-declare interface service_2 extends any__2 { }
+interface service_2 extends any__2 { }
 
-export declare interface ServiceImpl {
+export interface ServiceImpl {
     (this: Service, srv: Service): any
 }
 
 /**
  	 * Dictionary of all services constructed and/or connected.
  	 */
-export declare const services: cds_services;
+export const services: cds_services;
 
-declare type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
 
 /** @private */
-export declare type source = UnionToIntersection<ref | SELECT_2> & { as?: name, join?: name, on?: xpr }
+export type source = UnionToIntersection<ref | SELECT_2> & { as?: name, join?: name, on?: xpr }
 
 /**
  * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx#cds-spawn)
  */
-export declare function spawn (options: SpawnOptions, fn: (tx: Transaction) => object): SpawnEventEmitter
+export function spawn (options: SpawnOptions, fn: (tx: Transaction) => object): SpawnEventEmitter
 
-export declare class SpawnEventEmitter {
+export class SpawnEventEmitter {
 
     on<U extends keyof SpawnEvents>(
     event: U, listener: SpawnEvents[U]
@@ -2301,21 +2394,21 @@ export declare class SpawnEventEmitter {
 
 }
 
-export declare interface SpawnEvents {
+export interface SpawnEvents {
     succeeded: (res: any) => void
     failed: (error: any) => void
     done: () => void
 }
 
-export declare type SpawnOptions = {
+export type SpawnOptions = {
     [key: string]: any,
     every?: number,
     after?: number,
 }
 
-export declare type SQL = string
+export type SQL = string
 
-declare type StaticSELECT<T> = typeof SELECT_3
+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>)
@@ -2323,27 +2416,26 @@ declare type StaticSELECT<T> = typeof SELECT_3
 & SELECT_from // as it is not directly quantified, ...
 & SELECT_one
 
-export declare const stream: Service['stream'];
+export const stream: Service['stream'];
 
-export declare const string: typeof string_;
+const string: typeof string_;
 
-declare class string_ extends scalar { }
+class string_ extends scalar { }
 
-declare class String_2 extends string { }
-export { String_2 as String }
+class String_2 extends string { }
 
 /**
  * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-struct)
  */
-export declare interface struct extends Omit<csn.struct, 'items' | 'elements'> {}
+export interface struct extends Omit<csn.struct, 'items' | 'elements'> {}
 
-export declare class struct<K extends kinds = 'elements' | 'type'> extends type<K> implements WithElements {
+export class struct<K extends kinds = 'elements' | 'type'> extends type<K> implements WithElements {
     is_struct: true
 
     elements: Definitions<type<'type'>>
 }
 
-declare interface struct_2 extends type_2 {
+interface struct_2 extends type_2 {
 
     /**
      * References to definitions to be included.
@@ -2358,7 +2450,7 @@ declare interface struct_2 extends type_2 {
  * The final result of each subquery will be the property itself:
  * `Book.title` == `Subqueryable<Book>.title()`
  */
-declare type Subqueryable<T> = T extends Primitive	? unknown
+type Subqueryable<T> = T extends Primitive	? unknown
 // composition of many/ association to many
 : T extends readonly unknown[] ? {
 
@@ -2400,14 +2492,14 @@ declare type Subqueryable<T> = T extends Primitive	? unknown
     (fn: ((a: QLExtensions<T>) => any) | '*'): T,
 }
 
-declare type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params: unknown[]) => T
+type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params: unknown[]) => T
 
 /**
  * Target for any QL operation
  */
-declare type Target = linked_2.entity | Definition_2 | string
+type Target = linked_2.classes.entity | Definition | string
 
-declare class Test extends Axios {
+class Test extends Axios {
 
     test: Test
 
@@ -2422,11 +2514,11 @@ declare class Test extends Axios {
      */
     verbose (v: boolean): this
 
-    get chai (): typeof chai
+    get chai (): typeof import('chai')
 
-    get expect (): typeof chai.expect
+    get expect (): typeof import('chai').expect
 
-    get assert (): typeof chai.assert
+    get assert (): typeof import('chai').assert
 
     get data (): DataUtil
 
@@ -2438,7 +2530,7 @@ declare class Test extends Axios {
         release(): void,
     }
 
-    then (r: (args: { server: http.Server, url: string }) => void): void
+    then (r: (args: { server: import('http').Server, url: string }) => void): void
 
     // get sleep(): (ms: number) => Promise<void>;
     // get spy(): <T, K extends keyof T>(o: T, f: K) => T[K] extends (...args: infer TArgs) => infer TReturnValue
@@ -2447,7 +2539,7 @@ declare class Test extends Axios {
 
 }
 
-export declare const test: {
+export const test: {
     Test: typeof Test,
 
     /**
@@ -2463,80 +2555,80 @@ export declare const test: {
     in (dirname: string): Test,
 };
 
-export declare class Time extends date { }
+class Time extends date { }
 
-export declare class TimeStamp extends DateTime { }
+class TimeStamp extends DateTime { }
 
 /**
  * DO NOT USE
  * @internal
  */
-export declare type _TODO = any
+export type _TODO = any
 
-export declare interface Transaction extends Service {
+export interface Transaction extends Service {
     commit(): Promise<void>
     rollback(): Promise<void>
 }
 
-export declare const transaction: Service['transaction'];
+export const transaction: Service['transaction'];
 
 /**
  * Starts or joins a transaction
  * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx)
  */
-export declare const tx: {
+export const tx: {
     (fn: (tx: Transaction) => object): Promise<any>,
     (context?: object): Transaction,
     (context: object, fn: (tx: Transaction) => object): Promise<any>,
 };
 
-export declare interface type extends Omit<csn.type, 'items'> {
+export interface type extends Omit<csn.type, 'items'> {
     items: type
 }
 
-export declare class type<K extends kinds = 'type'> extends any_<K> { }
+export class type<K extends kinds = 'type'> extends any_<K> { }
 
-declare interface type_2 extends any__2 {
+interface type_2 extends any__2 {
     type?: FQN
     items?: type_2
 }
 
-export declare type TypedRequest<T> = Omit<Request_2, 'data'> & { data: T }
+export type TypedRequest<T> = Omit<Request_2, 'data'> & { data: T }
 
-export declare namespace types {
+export namespace types {
     export type event = eventName | eventName[]
     export type eventName = string
     | 'CREATE' | 'READ' | 'UPDATE' | 'DELETE'
     | 'NEW' | 'EDIT' | 'PATCH' | 'SAVE'
     | 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE'
     | 'COMMIT' | 'ROLLBACK'
-    export type target = string | linked_2.Definition | linked_2.entity | (string | linked_2.Definition | linked_2.entity)[] | ArrayConstructable
+    export type target = string | linked_2.Definition | linked_2.classes.entity | (string | linked_2.Definition | linked_2.classes.entity)[] | ArrayConstructable
 }
 
-export declare class UInt8 extends Integer { }
+class UInt8 extends Integer { }
 
-export declare const unboxed: (service: Service) => Service;
+export const unboxed: (service: Service) => Service;
 
-declare type UnionsToIntersections<U> = Array<UnionToIntersection<Scalarise<U>>>
+type UnionsToIntersections<U> = Array<UnionToIntersection<Scalarise<U>>>
 
-declare type UnionToIntersection<U> = Partial<(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never>
+type UnionToIntersection<U> = Partial<(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never>
 
-declare type Unwrap<T> = T extends ArrayConstructable
+type Unwrap<T> = T extends ArrayConstructable
 ? SingularType<T>
 : T extends Array<infer U>
 ? U
 : T
 
-export declare const update: Service['update'];
+export const update: Service['update'];
 
-declare type UPDATE_2 = { UPDATE: {
+type UPDATE_2 = { UPDATE: {
         entity: ref | name,
         data: { [key: string]: expr },
         where?: predicate,
     }, }
 export { UPDATE_2 as UPDATE }
 
-declare class UPDATE_3<T> extends ConstructedQuery {
+class UPDATE_3<T> extends ConstructedQuery {
 
     // cds-typer plural
     static entity<T extends ArrayConstructable<any>> (entity: T, primaryKey?: PK): UPDATE_3<SingularType<T>>
@@ -2567,7 +2659,7 @@ declare class UPDATE_3<T> extends ConstructedQuery {
 
 }
 
-declare type UPSERT_2 = { UPSERT: {
+type UPSERT_2 = { UPSERT: {
         into: ref | name,
         columns: string[],
         entries: data[],
@@ -2576,7 +2668,7 @@ declare type UPSERT_2 = { UPSERT: {
     }, }
 export { UPSERT_2 as UPSERT }
 
-declare class UPSERT_3<T> extends ConstructedQuery {
+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>>)
@@ -2607,7 +2699,7 @@ declare class UPSERT_3<T> extends ConstructedQuery {
  * Represents the user in a given context.
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/authentication#cds-user)
  */
-export declare class User {
+export class User {
 
     constructor (obj?: string | { id: string, attr: Record<string, string>, roles: Array<string> | Record<string, string> } | User)
     id: string
@@ -2635,7 +2727,7 @@ export declare class User {
 /**
  * Provides a set of utility functionss
  */
-export declare const utils: {
+export const utils: {
 
     /**
      	 * Generates a new v4 UUID
@@ -2683,9 +2775,9 @@ export declare const utils: {
      	 */
     write: {
         (data: object): {
-            to(...file: string[]): Promise<ReturnType<typeof fs.promises.writeFile>>,
+            to(...file: string[]): Promise<ReturnType<typeof import('node:fs').promises.writeFile>>,
         },
-        (file: string, data: object): Promise<ReturnType<typeof fs.promises.writeFile>>,
+        (file: string, data: object): Promise<ReturnType<typeof import('node:fs').promises.writeFile>>,
     },
 
     /**
@@ -2693,9 +2785,9 @@ export declare const utils: {
      	 */
     copy: {
         (src: string): {
-            to(...dst: string[]): Promise<ReturnType<typeof fs.promises.copyFile>>,
+            to(...dst: string[]): Promise<ReturnType<typeof import('node:fs').promises.copyFile>>,
         },
-        (dst: string, src: string): Promise<ReturnType<typeof fs.promises.copyFile>>,
+        (dst: string, src: string): Promise<ReturnType<typeof import('node:fs').promises.copyFile>>,
     },
 
     /**
@@ -2706,33 +2798,33 @@ export declare const utils: {
     /**
      	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rmdir-path
      	 */
-    rmdir: (...path: string[]) => Promise<ReturnType<typeof fs.promises.rm>>,
+    rmdir: (...path: string[]) => Promise<ReturnType<typeof import('node:fs').promises.rm>>,
 
 
     /**
      	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rimraf-path
      	 */
-    rimraf: (...path: string[]) => Promise<ReturnType<typeof fs.promises.rm>>,
+    rimraf: (...path: string[]) => Promise<ReturnType<typeof import('node:fs').promises.rm>>,
 
 
     /**
      	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rm-path
      	 */
-    rm: (...path: string[]) => Promise<ReturnType<typeof fs.promises.rm>>,
+    rm: (...path: string[]) => Promise<ReturnType<typeof import('node:fs').promises.rm>>,
 };
 
-export declare class UUID extends string { }
+class UUID extends string { }
 
 /** @private */
-export declare type val = { val: any }
+export type val = { val: any }
 
-export declare class Vector extends Binary { }
+class Vector extends Binary { }
 
-export declare const version: string;
+export const version: string;
 
-declare type Visitor = (def: any_, name: string, parent: any_, defs: Definitions) => void
+type Visitor = (def: any_, name: string, parent: any_, defs: Definitions) => void
 
-export declare interface WithElements {
+interface WithElements {
     elements: Definitions<type>
 }
 
@@ -2740,24 +2832,24 @@ export declare interface WithElements {
  * https://stackoverflow.com/a/53229567
  * @internal
  */
-declare type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
 
-export declare type XML = string
+export type XML = string
 
 /** @internal */
-declare type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
+type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
 
 /** @private */
-export declare type xpr = { xpr: _xpr }
+export type xpr = { xpr: _xpr }
 
 /** @private */
-export declare type _xpr = (expr | operator) []
+export type _xpr = (expr | operator) []
 
-export declare type YAML = string
+export type YAML = string
 
 export { }
 
-declare global {
+global {
   // these provide the functionality from SELECT, INSERT, etc in the global facade
   const SELECT: ql.QL<any>['SELECT']
   const INSERT: ql.QL<any>['INSERT']
@@ -2776,3 +2868,5 @@ declare global {
   type CREATE<T> = ql.CREATE<T>
   type DROP<T> = ql.DROP<T>
 }
+
+}