@cap-js/cds-types 0.1.0 → 0.3.0-beta.1

package/dist/cds-types.d.ts

@@ -0,0 +1,2778 @@
+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> {
+    (req: Omit<Request_2, 'data'> & { data: P }, next: Function): Promise<R> | R
+}
+
+export declare const any: typeof any_;
+
+export declare interface any_ extends csn.any_ {}
+
+export declare class any_<K extends kinds = kinds> {
+    private _: K // break covariance
+    constructor (...aspects: any[])
+
+    readonly name: string
+    // parked, might be deprecated
+    // is (kind: kinds | 'Association' | 'Composition'): boolean
+}
+
+declare interface any__2 {
+    kind?: kinds
+}
+
+export declare class ApplicationService extends Service {}
+
+export declare class array extends type<'type' | 'elements'> { }
+
+declare 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
+ */
+declare 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,
+}
+
+export declare 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 declare class Association extends type {
+    _target: entity
+
+    isAssociation: true
+
+    is2one: boolean
+
+    is2many: boolean
+
+}
+
+declare interface Association_2 extends type_2 {
+    type: 'cds.Association' | 'cds.Composition'
+    target: FQN
+
+    /**
+     * The specified cardinality. to-one = `{max:1}`, to-many = `{max:'*'}`
+     */
+    cardinality?: { src?: 1, min?: 1 | 0, max?: 1 | '*' }
+
+    /**
+     * The parsed on condition in case of unmanaged Associations
+     */
+    on?: predicate
+
+    /**
+     * The optionally specified keys in case of managed Associations
+     */
+    keys?: (ref & { as: string })[]
+}
+
+declare type Awaitable<T, I> = T & Promise<I>
+
+declare class Axios {
+
+    get axios (): AxiosInstance
+    get: AxiosInstance['get'];
+
+    put: AxiosInstance['put']
+
+    post: AxiosInstance['post']
+
+    patch: AxiosInstance['patch']
+
+    delete: AxiosInstance['delete']
+
+    options: AxiosInstance['options']
+
+    get GET (): Axios['get']
+
+    get PUT (): Axios['put']
+
+    get POST (): Axios['post']
+
+    get PATCH (): Axios['patch']
+
+    get DELETE (): Axios['delete']
+
+    get OPTIONS (): Axios['options']
+
+}
+
+export declare class Binary extends string { }
+
+export declare const boolean: typeof boolean_;
+
+declare class boolean_ extends scalar { }
+
+declare class Boolean_2 extends boolean { }
+export { Boolean_2 as Boolean }
+
+export declare const builtin: {
+
+    /**
+     * @see {@link models.linked.classes}
+     */
+    classes: typeof models.linked.classes,
+    types: Record<string, object>, // FIXME: value should be any class part of linked.classes
+};
+
+export declare type CDL = string
+
+declare namespace cds {
+    export {
+        log,
+        debug,
+        test,
+        ql,
+        QLExtensions,
+        csn,
+        delete_ as delete,
+        version,
+        home,
+        root,
+        requires,
+        extend,
+        lazify,
+        lazified,
+        entity,
+        event,
+        type,
+        array,
+        struct,
+        Association,
+        Composition,
+        builtin,
+        on,
+        once,
+        exit,
+        _cds,
+        cds_services,
+        connect,
+        server,
+        serve,
+        services,
+        service,
+        cds_serve_fluent,
+        cds_connect_options,
+        Middleswares,
+        middlewares,
+        env,
+        _TODO,
+        get,
+        load,
+        resolve,
+        reflect,
+        _flavor,
+        _odata_options,
+        _options,
+        JSON_2 as JSON,
+        YAML,
+        CDL,
+        SQL,
+        XML,
+        EDM,
+        EDMX,
+        filename,
+        model,
+        parse,
+        linked,
+        compile,
+        spawn,
+        Key,
+        QueryAPI,
+        Service,
+        ApplicationService,
+        MessagingService,
+        RemoteService,
+        DatabaseService,
+        Transaction,
+        ResultSet,
+        ServiceImpl,
+        EventHandler,
+        OnEventHandler,
+        OnErrorHandler,
+        Partial_2 as Partial,
+        OneOrMany,
+        CdsFunction,
+        TypedRequest,
+        CRUDEventHandler,
+        ActionEventHandler,
+        ResultsHandler,
+        SpawnEvents,
+        SpawnEventEmitter,
+        types,
+        SpawnOptions,
+        context,
+        tx,
+        entities,
+        run,
+        foreach,
+        stream,
+        read,
+        create,
+        insert,
+        update,
+        transaction,
+        db,
+        outboxed,
+        unboxed,
+        EventContext,
+        Event_2 as Event,
+        Request_2 as Request,
+        User,
+        Privileged,
+        utils,
+        Query,
+        SELECT_2 as SELECT,
+        INSERT_2 as INSERT,
+        UPSERT_2 as UPSERT,
+        UPDATE_2 as UPDATE,
+        DELETE_2 as DELETE,
+        CREATE_2 as CREATE,
+        DROP_2 as DROP,
+        primitive,
+        data,
+        name,
+        source,
+        column_expr,
+        predicate,
+        ordering_term,
+        expr,
+        ref,
+        val,
+        xpr,
+        _xpr,
+        operator,
+        function_call,
+        enum_literal,
+        expr_literal,
+        ModelPart,
+        Definition,
+        CSN,
+        mixin,
+        Protocol,
+        Column,
+        Definitions,
+        WithElements,
+        any_,
+        any,
+        aspect,
+        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,
+        context_,
+        service_,
+        action,
+        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 }
+
+export declare 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: {
+
+    /** Shortcut for `cds.compile.to.csn()` */
+    cdl (model: CDL, o?: _options): csn.CSN,
+
+    for: {
+        odata (model: csn.CSN, o?: _options): csn.CSN,
+        sql (model: csn.CSN, o?: _options): csn.CSN,
+    },
+    to: {
+        parsed: {
+            csn (files: filename[], o?: _options): Promise<csn.CSN>,
+            csn (model: CDL, o?: _options): csn.CSN,
+        },
+        xtended: {
+            csn (files: filename[], o?: _options): Promise<csn.CSN>,
+            csn (model: CDL, o?: _options): csn.CSN,
+        },
+        inferred: {
+            csn (files: filename[], o?: _options): Promise<csn.CSN>,
+            csn (model: CDL, o?: _options): csn.CSN,
+        },
+        csn (files: filename[], o?: _options): Promise<csn.CSN>,
+        csn (model: CDL, o?: _options): csn.CSN,
+        yml (model: csn.CSN, o?: _options): YAML,
+        yaml (model: csn.CSN, o?: _options): YAML,
+        json (model: csn.CSN, o?: _options): JSON_2,
+        sql (model: csn.CSN, o?: _options): SQL[],
+        cdl (model: csn.CSN, o?: _options): CDL | Iterable<[CDL, { file: filename }]>,
+        edm (model: csn.CSN, o?: _options | _odata_options): EDM | string,
+        edmx (model: csn.CSN, o?: _options | _odata_options): EDMX | Iterable<[EDMX, { file: filename }]>,
+        hdbcds (model: csn.CSN, o?: _options): SQL | Iterable<[SQL, { file: filename }]>,
+        hdbtable (model: csn.CSN, o?: _options): SQL | Iterable<[SQL, { file: filename }]>,
+    },
+
+    /** Fluent API variant */
+    (model: csn.CSN | CDL): {
+        for: {
+            odata (o?: _options): csn.CSN,
+            sql (o?: _options): csn.CSN,
+        },
+        to: {
+            parsed: { csn (o?: _options): csn.CSN },
+            xtended: { csn (o?: _options): csn.CSN },
+            inferred: { csn (o?: _options): csn.CSN },
+            csn (o?: _options): csn.CSN,
+            yml (o?: _options): YAML,
+            yaml (o?: _options): YAML,
+            json (o?: _options): JSON_2,
+            sql (o?: _options): SQL[],
+            cdl (o?: _options): CDL | Iterable<[CDL, { file: filename }]>,
+            edm (o?: _options | _odata_options): EDM | string,
+            edmx (o?: _options | _odata_options): EDMX | Iterable<[EDMX, { file: filename }]>,
+            hdbcds (o?: _options): SQL | Iterable<[SQL, { file: filename }]>,
+            hdbtable (o?: _options): SQL | Iterable<[SQL, { file: filename }]>,
+        },
+    },
+
+    /** Async fluent variant reading from files */
+    (files: filename[]): {
+        for: {
+            odata (o?: _options): Promise<csn.CSN>,
+            sql (o?: _options): Promise<csn.CSN>,
+        },
+        to: {
+            parsed: { csn (o?: _options): Promise <csn.CSN> },
+            xtended: { csn (o?: _options): Promise <csn.CSN> },
+            inferred: { csn (o?: _options): Promise <csn.CSN> },
+            csn (o?: _options): Promise <csn.CSN>,
+            yml (o?: _options): Promise <YAML>,
+            yaml (o?: _options): Promise <YAML>,
+            json (o?: _options): Promise <JSON_2>,
+            sql (o?: _options): Promise <SQL[]>,
+            cdl (o?: _options): Promise <CDL | Iterable<[CDL, { file: filename }]>>,
+            edm (o?: _options | _odata_options): Promise <EDM | string>,
+            edmx (o?: _options | _odata_options): Promise <EDMX | Iterable<[EDMX, { file: filename }]>>,
+            hdbcds (o?: _options): Promise <SQL | Iterable<[SQL, { file: filename }]>>,
+            hdbtable (o?: _options): Promise <SQL | Iterable<[SQL, { file: filename }]>>,
+        },
+    },
+};
+
+export declare class Composition extends Association {
+    isComposition: true
+}
+
+export declare const connect: {
+
+    /**
+     		 * Connects to a specific datasource.
+     		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
+     		 */
+    to(datasource: string, options?: cds_connect_options): Promise<Service>,
+
+    /**
+     		 * Connects to a specific datasource via options.
+     		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
+     		 */
+    to(options: cds_connect_options): Promise<Service>,
+
+    /**
+     		 * Connects the primary datasource.
+     		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect)
+     		 */
+    // API extractor cannot handle the direct usages of the cds namespace in typeof cds, so add an indirection.
+    (options?: string | cds_connect_options): Promise<_cds>, // > cds.connect(<options>)
+};
+
+declare interface Constructable<T = any> {
+    new(...args: any[]): T
+}
+
+declare class ConstructedQuery {
+
+    then (_resolved: (x: any) => any, _rejected: (e: Error) => any): any
+
+}
+
+/**
+ * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx#event-contexts
+ */
+export declare let context: EventContext | undefined;
+
+export declare interface context_ extends csn.context {}
+
+export declare class context_ extends any_ { }
+
+declare interface context_2 extends any__2 { }
+
+declare namespace CQN {
+    export {
+        Query,
+        SELECT_2 as SELECT,
+        INSERT_2 as INSERT,
+        UPSERT_2 as UPSERT,
+        UPDATE_2 as UPDATE,
+        DELETE_2 as DELETE,
+        CREATE_2 as CREATE,
+        DROP_2 as DROP,
+        primitive,
+        data,
+        name,
+        source,
+        column_expr,
+        predicate,
+        ordering_term,
+        expr,
+        ref,
+        val,
+        xpr,
+        _xpr,
+        operator,
+        function_call,
+        enum_literal,
+        expr_literal
+    }
+}
+
+export declare const create: Service['create'];
+
+declare type CREATE_2 = { CREATE: {
+        entity: entity_2 | name,
+        as: SELECT_2,
+    }, }
+export { CREATE_2 as CREATE }
+
+declare class CREATE_3<T> extends ConstructedQuery {
+
+    static entity (entity: Target): CREATE_3<any>
+
+    CREATE: CQN.CREATE['CREATE']
+
+}
+
+export declare 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 {
+
+    /**
+     * The assigned namespace. If parsed from multiple sources,
+     * this is the topmost model's namespace, if any, not the
+     * ones of imported models.
+     */
+    namespace?: string
+
+    /**
+     * The list of usings in this parsed model. Not available after
+     * imports have been resolved into a merged model.
+     */
+    requires?: string[]
+
+    /**
+     * All definitions in the model including those from imported models.
+     */
+    definitions?: Record<FQN, Definition_2>
+
+    /**
+     * All extensions in the model including those from imported models.
+     * Not available after extensions have been applied.
+     */
+    extensions?: Extension[]
+
+    /**
+     * The names of the files from which this model has been loaded.
+     */
+    $sources?: string[]
+}
+
+/** @private */
+export declare type data = Record<string, any>
+
+export declare class DatabaseService extends Service {
+    deploy (model?: csn.CSN | string): Promise<csn.CSN>
+    begin (): Promise<void>
+    commit (): Promise<void>
+    rollback (): Promise<void>
+}
+
+declare class DataUtil {
+
+    delete (db?: Service): Promise<void>
+
+    reset (db?: Service): Promise<void>
+
+    /**
+     * @deprecated if needed, call `reset()`, considering test performance
+     */
+    autoReset (enabled: boolean): this
+
+}
+
+export declare class date extends scalar { }
+
+declare class Date_2 extends date { }
+export { Date_2 as Date }
+
+export declare class DateTime extends date { }
+
+export declare const db: DatabaseService;
+
+/**
+ * Shortcut to `cds.log(...).debug`, returning `undefined` if `cds.log(...)._debug` is `false`.
+ * Use like this:
+ * @example
+ * ```js
+ *   const dbg = cds.debug('foo')
+ *   ...
+ *   dbg && dbg('message')
+ * ```
+ *
+ * @param name - logger name
+ */
+export declare function debug (name: string): undefined | Log
+
+export declare class Decimal extends Float { }
+
+export declare type Definition = any_
+
+/**
+ * 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
+
+/**
+ * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#iterable)
+ */
+export declare type Definitions<T extends any_ = any_> = IterableMap<T>
+
+declare const delete_: Service['delete'];
+export { delete_ as delete };
+
+declare type DELETE_2 = { DELETE: {
+        from: ref | name,
+        where?: predicate,
+    }, }
+export { DELETE_2 as DELETE }
+
+declare class DELETE_3<T> extends ConstructedQuery {
+
+    static from:
+    TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
+    & ((entity: Target | ArrayConstructable, primaryKey?: PK) => DELETE_3<any>)
+    & ((subject: ref) => DELETE_3<any>)
+
+    byKey (primaryKey?: PK): this
+
+    where (predicate: object): this
+
+    where (...expr: any[]): this
+
+    and (predicate: object): this
+
+    and (...expr: any[]): this
+    DELETE: CQN.DELETE['DELETE']
+
+}
+
+export declare class Double extends Float { }
+
+declare type DROP_2 = { DROP: {
+        entity: name,
+        table: ref,
+        view: ref,
+    }, }
+export { DROP_2 as DROP }
+
+declare class DROP_3<T> extends ConstructedQuery {
+
+    static entity (entity: Target): DROP_3<any>
+
+    DROP: CQN.DROP['DROP']
+
+}
+
+export declare type EDM = { $version: string }
+
+export declare type EDMX = XML
+
+declare type Element = type_2 & struct_2 & Association_2
+
+export declare 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 declare class entity extends struct<'entity'> {
+    is_entity: true
+
+    keys: Definitions<type>
+
+    associations: Definitions<Association>
+
+    compositions: Definitions<Composition>
+
+    actions: Definitions<action>
+
+    texts?: entity
+
+    drafts?: entity
+}
+
+declare interface entity_2 extends Omit<struct_2, 'elements'> {
+
+    /**
+     * Entities with a query signify a view
+     */
+    query?: SELECT_2
+
+    /**
+     * Elements of entities may have additional qualifiers
+     */
+    elements: EntityElements
+    // REVISIT: following should move to LinkedCSN
+    keys: { [name: string]: Definition_2 }
+    drafts?: entity_2
+}
+
+declare type EntityElements = {
+    [name: string]: Element & {
+        key?: boolean,
+        virtual?: boolean,
+        unique?: boolean,
+        notNull?: boolean,
+    },
+}
+
+export declare type enum_literal = { '#': string }
+
+/**
+ * Access to the configuration for Node.js runtime and tools.
+ * The object is the effective result of configuration merged from various sources,
+ * filtered through the currently active profiles, thus highly dependent on the current working
+ * directory and process environment.
+ */
+export declare const env: {
+    build: _TODO,
+    hana: _TODO,
+    i18n: {
+        languages: string[],
+        default_language: string,
+        folders: string[],
+        [key: string]: any,
+    },
+    requires: env.Requires,
+    folders: {
+        app: string,
+        db: string,
+        srv: string,
+        fts: string,
+        [key: string]: string, // to allow additional values
+    },
+    odata: _TODO,
+    query: _TODO,
+    sql: _TODO,
+} & { [key: string]: any };
+
+export declare namespace env {
+
+    export interface MockUser {
+        tenant?: string
+        roles?: string[]
+        features?: string[]
+    }
+
+    export interface MockUsers {
+        alice: MockUser
+        bob: MockUser
+        carol: MockUser
+        dave: MockUser
+        erin: MockUser
+        fred: MockUser
+        [key: string]: MockUser | undefined
+    }
+
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    export type Requires = {
+        auth: {
+            kind: 'dummy' | 'mocked' | 'basic' | 'xsuaa' | 'ias' | string,
+            impl: string,
+            users?: MockUsers,
+            tenants?: {
+                [key: string]: {
+                    features?: string[],
+                },
+            },
+            credentials?: Credentials,
+            binding?: Binding,
+            [key: string]: any,
+        },
+        db: {
+            kind: 'hana' | 'sqlite' | 'sql' | string,
+            binding?: Binding,
+            [key: string]: any,
+        },
+        multitenancy: boolean | { kind: string, jobs: {
+                clusterSize: number,
+                workerSize: number,
+                t0: string,
+                [key: string]: any,
+            },},
+        toggles: boolean,
+        extensibility: boolean | {
+            model: string[],
+            tenantCheckInterval: number,
+            [key: string]: any,
+        },
+        messaging: {
+            kind: 'file-based-messaging' | 'redis-messaging' | 'local-messaging' | 'enterprise-messaging' | 'enterprise-messaging-shared' | string,
+            format: 'cloudevents' | string,
+            [key: string]: any,
+        },
+        [key: string]: any,
+    }
+
+    export type Binding = {
+        type: 'cf' | 'k8s' | string,
+        apiEndpoint?: string,
+        org?: string,
+        space?: string,
+        instance?: string,
+        key?: string,
+    }
+
+    export type Credentials = {
+        clientid?: string,
+        clientsecret?: string,
+        url?: string,
+        xsappname?: string,
+        certurl?: string,
+        certificate?: string,
+        [key: string]: any,
+    }
+}
+
+export declare class event extends aspect<'event'> {}
+
+/**
+ * @see [capire docs](https://cap.cloud.sap/docs/node.js/events)
+ */
+declare class Event_2 extends EventContext {
+
+    event: string
+
+    data: any
+
+    headers: any
+
+}
+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 {
+
+    constructor (properties: { event: string, data?: object, query?: object, headers?: object })
+    http?: { req: express.Request, res: express.Response }
+
+    tenant: string
+
+    user: User
+
+    id: string
+
+    locale: `${string}_${string}`
+
+    timestamp: Date
+
+    features?: { [key: string]: boolean }
+
+}
+
+export declare interface EventHandler {
+    // (msg : types.EventMessage) : Promise<any> | any | void
+    (req: Request_2): Promise<any> | any | void
+}
+
+/**
+ * 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 declare type expr = ref | val | xpr | function_call | SELECT_2
+
+export declare type expr_literal = { '=': string }
+
+/**
+ * Add aspects to a given object, for example:
+ *
+ * @example
+ * ```js
+ *    extend (Object.prototype) .with (class {
+ *       get foo() { return ... }
+ *       bar() {...}
+ *    }.prototype)
+ * ```
+ */
+export declare function extend<T> (target: T): {
+    with<E extends readonly any[]>(...ext: E): T & Intersect<E>,
+}
+
+/**
+ * Extensions capture `extend Foo with { ... }` directives.
+ */
+declare type Extension = {
+    extend: FQN,
+    elements?: { [name: string]: Element },
+    includes?: FQN[],
+}
+
+export declare type filename = string
+
+declare type Filter = string | (<T extends any_ = any_>(def: T) => boolean)
+
+export declare type _flavor = 'parsed' | 'xtended' | 'inferred'
+
+export declare class Float extends number { }
+
+export declare const foreach: Service['foreach'];
+
+declare type Formatter = {
+
+    /**
+     * Custom format function
+     *
+     * @param module - logger name
+     * @param level - log level
+     * @param args - additional arguments
+     * @returns an array of arguments, which are passed to the logger (for example, `console.log()`)
+     */
+    (module: string, level: number, args: any[]): any[],
+}
+
+/**
+ * The fully-quality name of a definition.
+ */
+declare type FQN = string
+
+/** @private */
+export declare type function_call = { func: string, args: { [key: string]: any }[] }
+
+/**
+ * Loads and parses models from the specified files.
+ * Uses `cds.resolve` to fetch the respective models.
+ * 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 declare const home: string;
+
+export declare const insert: Service['insert'];
+
+declare type INSERT_2 = { INSERT: {
+        into: ref | name,
+        entries: data[],
+        columns: string[],
+        values: primitive[],
+        rows: primitive[][],
+        as: SELECT_2,
+    }, }
+export { INSERT_2 as INSERT }
+
+declare 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
+
+    columns (...col: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]): this
+
+    columns (...col: string[]): this
+
+    values (...val: any[]): this
+
+    rows (...row: any[]): this
+
+    as (select: SELECT_3<T>): this
+    INSERT: CQN.INSERT['INSERT']
+
+}
+
+export declare class Int16 extends Integer { }
+
+export declare class Int32 extends Integer { }
+
+export declare class Int64 extends Integer { }
+
+export declare class Integer extends number { }
+
+declare type Intersect<T extends readonly unknown[]> = T extends [infer Head, ...infer Tail]
+? Head & Intersect<Tail>
+: unknown
+
+/**
+ * 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>
+
+declare type JSON_2 = string
+export { JSON_2 as JSON }
+
+export declare type Key = number | string | any
+
+declare type kinds = 'aspect' | 'entity' | 'type' | 'event' | 'action' | 'function' | 'service' | 'context' | 'elements'
+
+export declare class LargeBinary extends Binary { }
+
+export declare 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.
+ */
+export declare 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.
+ */
+export declare function lazify<T> (target: T): T
+
+declare 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: {
+
+    /**
+     * 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,
+
+    /**
+     * 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,
+};
+
+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
+    }
+}
+
+declare namespace LinkedClasses {
+    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
+    }
+}
+
+/**
+ * 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>
+
+declare type Log = {
+
+    /**
+     * Logs a message
+     *
+     * @param message - text to log
+     * @param optionalParams - additional parameters, same as in `console.log(text, param1, ...)`
+     */
+    (message?: any, ...optionalParams: any[]): void,
+}
+
+/**
+ * Create a new logger, or install a custom log formatter
+ */
+export declare const log: LogFactory;
+
+declare type LogFactory = {
+
+    /**
+     * Returns a trace logger for the given module if trace is switched on for it,
+     * otherwise returns null. All cds runtime packages use this method for their
+     * trace and debug output.
+     *
+     * By default this logger would prefix all output with `[sql] - `
+     * You can change this by specifying another prefix in the options:
+     * @example
+     * ```js
+     *   const LOG = cds.log('sql|db', { prefix: 'cds.ql' })
+     * ```
+     *
+     * Call `cds.log()` for a given module again to dynamically change the log level
+     * of all formerly created loggers, for example:
+     * @example
+     * ```js
+     *   const LOG = cds.log('sql')
+     *   LOG.info ('this will show, as default level is info')
+     *   cds.log('sql', 'warn')
+     *   LOG.info('this will be suppressed now')
+     * ```
+     *
+     * @param name - logger name
+     * @param options - level, label and prefix
+     * @returns the logger
+     * @see [capire](https://cap.cloud.sap/docs/node.js/cds-log)
+     */
+    (name: string, options?: string | number | { level?: LogLevel, label?: string, prefix?: string }): Logger,
+
+    /**
+     * Set a custom formatter function like that:
+     * ```js
+     *   cds.log.format = (module, level, ...args) => [ '[', module, ']', ...args ]
+     * ```
+     *
+     * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
+     */
+    format: Formatter,
+
+    /**
+     * Set a custom logger.
+     * ```js
+     *   cds.log.Logger = ...
+     * ```
+     */
+    Logger: Logger,
+
+    // FIXME
+    /* eslint-disable-next-line @typescript-eslint/ban-types */
+    winstonLogger (LoggerOptions?: { level?: string, levels?: any, format?: any, transports?: any, exitOnError?: boolean | Function, silent?: boolean }),
+}
+
+declare class Logger {
+
+
+    /**
+     * Logs with 'trace' level
+     */
+    trace: Log
+
+    /**
+     * Logs with 'debug' level
+     */
+    debug: Log
+
+    /**
+     * Logs with 'info' level
+     */
+    info: Log
+
+    /**
+     * Logs with 'warn' level
+     */
+    warn: Log
+
+    /**
+     * Logs with 'error' level
+     */
+    error: Log
+
+    /**
+     * Logs with default level
+     */
+    log: Log
+
+    /**
+     * @returns whether 'trace' level is active
+     */
+    _trace: boolean
+
+    /**
+     * @returns whether 'debug' level is active
+     */
+    _debug: boolean
+
+    /**
+     * @returns whether 'info' level is active
+     */
+    _info: boolean
+
+    /**
+     * @returns whether 'warn' level is active
+     */
+    _warn: boolean
+
+    /**
+     * @returns whether 'error' level is active
+     */
+    _error: boolean
+
+    /**
+     * Change the format for this logger instance:
+     * ```
+     *   cds.log('foo').setFormat((module, level, ...args) => [ '[', module, ']', ...args ])
+     * ```
+     *
+     * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
+     */
+    setFormat (formatter: Formatter)
+
+}
+
+declare type LogLevel = keyof typeof levels | Lowercase<keyof typeof levels> | levels
+
+export declare type ManagedAssociation = Association & {
+    foreignKeys: Definitions<type>,
+    keys: Column[],
+}
+
+export declare class MessagingService extends Service {}
+
+export declare 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,
+};
+
+/**
+ * Allows arbitrary property access. Can be used for explicitly casting
+ * classes you have added {@link mixin}s to.
+ * Use with caution, as the type system will no longer
+ * warn you about possibly missing properties.
+ * @example
+ * ```ts
+ * mixin(class struct { foo: string }))
+ *
+ * const s1 = new struct() as MixedIn<struct>
+ * s1.is_struct
+ * s1.foo
+ * s1.bar  // no error, despite not being defined :(
+ *
+ * const s2 = new struct() as struct & { foo: string }  // better!
+ * s2.is_struct
+ * s2.foo
+ * s2.bar  // error :)
+ * ```
+ */
+export declare type MixedIn<T> = T & { [key: string | number | symbol]: unknown }
+
+/**
+ * Using this will require you to explicitly cast all classes you added mixins to
+ * to be able to access the additional properties. If you want to allow any additional
+ * 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
+
+/**
+ * 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 declare type ModelPart<T extends any_> = IterableMap<T> & ((namespace: string) => IterableMap<T>)
+
+declare namespace models {
+    export {
+        get,
+        load,
+        resolve,
+        reflect,
+        _flavor,
+        _odata_options,
+        _options,
+        JSON_2 as JSON,
+        YAML,
+        CDL,
+        SQL,
+        XML,
+        EDM,
+        EDMX,
+        filename,
+        model,
+        parse,
+        linked,
+        compile
+    }
+}
+
+/** @private */
+export declare type name = string
+
+export declare const number: typeof number_;
+
+declare class number_ extends scalar { }
+
+export declare type _odata_options = {
+    flavor?: 'v2' | 'v4' | 'w4' | 'x4',
+    version?: 'v2' | 'v4',
+    structs?: boolean,
+    refs?: boolean,
+}
+
+/**
+ 	 * Emitted whenever a model is loaded using cds.load().
+ 	 */
+// 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
+
+/**
+ 	 * Emitted whenever a specific service is connected for the first time.
+ 	 */
+export declare 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
+
+/**
+ 	 * Emitted for each service served by cds.serve().
+ 	 */
+export declare 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
+
+/**
+ 	 * 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
+
+/**
+ 	 * Emitted by the default, built-in `server.js` when the http server
+ 	 * is shutdown.
+ 	 */
+export declare function on (event: 'shutdown', listener: () => void): _cds
+
+export declare function once (event: 'bootstrap', listener: (app: Application) => void): _cds
+
+export declare 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 declare function once (event: 'shutdown', listener: () => void): _cds
+
+export declare type OneOrMany<T> = T | T[]
+
+export declare interface OnErrorHandler {
+    (err: Error, req: Request_2): any | void
+}
+
+export declare interface OnEventHandler {
+    (req: Request_2, next: Function): Promise<any> | any | void
+}
+
+/** @private */
+export declare type operator = string
+
+export declare type _options = {
+    flavor?: _flavor,
+    plain?: boolean,
+    docs?: boolean,
+    names?: string,
+    odata?: _odata_options,
+} | _flavor
+
+/** @private */
+export declare type ordering_term = expr & { sort?: 'asc' | 'desc', nulls?: 'first' | 'last' }
+
+export declare 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: {
+
+    /** Shortcut to `cds.parse.cdl()` */
+    (cdl: CDL): csn.CSN,
+    cdl (cdl: CDL): csn.CSN,
+    cql (src: string): Query,
+    expr (src: string): expr,
+    xpr (src: string): _xpr,
+    ref (src: string): string[],
+};
+
+declare type Partial_2<T> = { [Key in keyof T]: undefined | T[Key] }
+export { Partial_2 as Partial }
+
+declare type PK = number | string | object
+
+declare type PluralType<T extends Constructable> = Array<InstanceType<T>>
+
+export declare type predicate = UnionsToIntersections<_xpr>
+
+declare type Primitive = string | number | boolean | Date
+
+/** @private */
+export declare type primitive = number | string | boolean | null
+
+/**
+ * Subclass for executing code with superuser privileges.
+ */
+export declare class Privileged extends User {
+
+    constructor ()
+
+    is (): boolean
+
+}
+
+declare type Projection<T> = (e: QLExtensions<T extends ArrayConstructable ? SingularType<T> : T>) => void
+
+/**
+ * @alpha
+ * related to .protocols getters
+ */
+export declare type Protocol = 'odata' | 'rest'
+
+declare class QL<T> {
+
+    SELECT: StaticSELECT<T>
+
+    INSERT: typeof INSERT_3
+    & ((...entries: object[]) => INSERT_3<any>) & ((entries: object[]) => INSERT_3<any>)
+
+    UPSERT: typeof UPSERT_3
+    & ((...entries: object[]) => UPSERT_3<any>) & ((entries: object[]) => UPSERT_3<any>)
+
+    UPDATE: typeof UPDATE_3
+    & typeof UPDATE_3.entity
+
+    DELETE: typeof DELETE_3
+    & ((...entries: object[]) => DELETE_3<any>) & ((entries: object[]) => DELETE_3<any>)
+
+    CREATE: typeof CREATE_3
+
+    DROP: typeof DROP_3
+
+}
+
+declare namespace ql {
+    export {
+        Query_2 as Query,
+        ConstructedQuery,
+        PK,
+        Primitive,
+        QLExtensions,
+        Target,
+        QLExtensions_,
+        Subqueryable,
+        Projection,
+        Awaitable,
+        StaticSELECT,
+        QL,
+        TaggedTemplateQueryPart,
+        SELECT_3 as SELECT,
+        SELECT_one,
+        SELECT_from,
+        INSERT_3 as INSERT,
+        UPSERT_3 as UPSERT,
+        DELETE_3 as DELETE,
+        UPDATE_3 as UPDATE,
+        CREATE_3 as CREATE,
+        DROP_3 as DROP
+    }
+}
+export { ql }
+
+export declare 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> = {
+    [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>>
+
+export declare type Query = Partial<SELECT_2 & INSERT_2 & UPDATE_2 & DELETE_2 & CREATE_2 & DROP_2 & UPSERT_2>
+
+declare type Query_2 = CQN.Query
+
+export declare class QueryAPI {
+
+    entities: linked_2.CSN['entities']
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    read: {
+        <T extends ArrayConstructable>(entity: T, key?: Key): Awaitable<SELECT_3<T>, InstanceType<T>>,
+        <T>(entity: linked_2.Definition | string, key?: Key): SELECT_3<T>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    create: {
+        <T extends ArrayConstructable>(entity: T, key?: Key): INSERT_3<T>,
+        <T>(entity: linked_2.Definition | string, key?: Key): INSERT_3<T>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    insert: {
+        <T extends ArrayConstructable>(data: T): INSERT_3<T>,
+        <T>(data: object | object[]): INSERT_3<T>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    upsert: {
+        <T extends ArrayConstructable>(data: T): UPSERT_3<T>,
+        <T>(data: object | object[]): UPSERT_3<T>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    update: {
+        <T extends ArrayConstructable>(entity: T, key?: Key): UPDATE_3<T>,
+        <T>(entity: linked_2.Definition | string, key?: Key): UPDATE_3<T>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    run: {
+        (query: ConstructedQuery | ConstructedQuery[]): Promise<ResultSet | any>,
+        (query: Query_2): Promise<ResultSet | any>,
+        (query: string, args?: any[] | object): Promise<ResultSet | any>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#srv-stream-column)
+     */
+    stream: {
+        (column: string): {
+            from(entity: linked_2.Definition | string): {
+                where(filter: any): ReadableStream,
+            },
+        },
+        (query: Query_2): Promise<ReadableStream>,
+    }
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
+     */
+    delete<T>(entity: linked_2.Definition | string, key?: Key): DELETE_3<T>
+
+    /**
+     * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#srv-foreach-entity)
+     */
+    foreach (query: Query_2, callback: (row: object) => void): this
+
+    /**
+     * @deprecated use {@link QueryAPI.tx} instead
+     */
+    transaction: QueryAPI['tx']
+
+    tx: {
+        (fn: (tx: Transaction) => object): Promise<unknown>,
+        (context?: object): Transaction,
+        (context: object, fn: (tx: Transaction) => object): Promise<unknown>,
+    }
+
+}
+
+export declare const read: Service['read'];
+
+/** @private */
+export declare 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 declare class RemoteService extends Service {}
+
+/**
+ * @see [capire docs](https://cap.cloud.sap/docs/node.js/events)
+ */
+declare class Request_2 extends Event_2 {
+
+    params: (string | object)[]
+
+    method: string
+
+    path: string
+
+    target: Definition
+
+    /**
+     * Shortcut to {@link Request.target | target (entity) name}
+     * @see https://cap.cloud.sap/docs/node.js/events#req-entity
+     */
+    entity: string
+
+    query: Query
+
+    subject: ref
+
+    reply (results: any): void
+
+    notify (code: number, message: string, target?: string, args?: any[]): Error
+
+    info (code: number, message: string, target?: string, args?: any[]): Error
+
+    warn (code: number, message: string, target?: string, args?: any[]): Error
+
+    error (code: number, message: string, target?: string, args?: any[]): Error
+
+    reject (code: number, message: string, target?: string, args?: any[]): Error
+
+    notify (code: number, message: string, args?: any[]): Error
+
+    info (code: number, message: string, args?: any[]): Error
+
+    warn (code: number, message: string, args?: any[]): Error
+
+    error (code: number, message: string, args?: any[]): Error
+
+    reject (code: number, message: string, args?: any[]): Error
+
+    notify (message: string, target?: string, args?: any[]): Error
+
+    info (message: string, target?: string, args?: any[]): Error
+
+    warn (message: string, target?: string, args?: any[]): Error
+
+    error (message: string, target?: string, args?: any[]): Error
+
+    reject (message: string, target?: string, args?: any[]): Error
+
+    notify (message: { code?: number | string, message: string, target?: string, args?: any[] }): Error
+
+    info (message: { code?: number | string, message: string, target?: string, args?: any[] }): Error
+
+    warn (message: { code?: number | string, message: string, target?: string, args?: any[] }): Error
+
+    error (message: { code?: number | string, message: string, target?: string, args?: any[], status?: number }): Error
+
+    reject (message: { code?: number | string, message: string, target?: string, args?: any[], status?: number }): Error
+
+}
+export { Request_2 as Request }
+
+export declare const requires: env.Requires;
+
+/**
+ * Resolves given file or module name(s) to an array of absolute file names.
+ * Uses Node's `require.resolve` internally with the following additions:
+ * - relative names are resolved relative to the current working directory instead of the current JavaScript module; hence, use __dirname if you want to find or load models relative to the current module.
+ * - if no file extension is given, `.csn` and `.cds` will be appended in that order.
+ * @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 declare interface ResultSet extends Array<object> {}
+
+export declare interface ResultsHandler {
+    (results: any[], req: Request_2): void
+    (each: any, req: Request_2): void
+}
+
+export declare const root: string;
+
+export declare const run: Service['run'];
+
+export declare class scalar extends type { }
+
+declare type Scalarise<A> = A extends Array<infer N> ? N : A
+
+declare type SELECT_2 = { SELECT: {
+        distinct?: true,
+        one?: boolean,
+        from: source,
+        mixin?: { [key: string]: expr },
+        columns?: column_expr[],
+        excluding?: string[],
+        where?: predicate,
+        having?: predicate,
+        groupBy?: expr[],
+        orderBy?: ordering_term[],
+        limit?: { rows: val, offset: val },
+    }, }
+export { SELECT_2 as SELECT }
+
+declare class SELECT_3<T> extends ConstructedQuery {
+
+    static one: SELECT_one & { from: SELECT_one }
+
+    static distinct: typeof SELECT_3
+
+    static from: SELECT_from
+
+    from: SELECT_from & TaggedTemplateQueryPart<this>
+    & ((entity: Target, primaryKey?: PK, projection?: Projection<unknown>) => this)
+
+    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)
+
+    and: TaggedTemplateQueryPart<this>
+    & ((predicate: object) => this)
+    & ((...expr: any[]) => this)
+
+    having: TaggedTemplateQueryPart<this>
+    & ((...expr: string[]) => this)
+    & ((predicate: object) => this)
+
+    groupBy: TaggedTemplateQueryPart<this>
+    & ((...expr: string[]) => this)
+
+    orderBy: TaggedTemplateQueryPart<this>
+    & ((...expr: string[]) => this)
+
+    limit: TaggedTemplateQueryPart<this>
+    & ((rows: number, offset?: number) => this)
+
+    forShareLock (): this
+
+    forUpdate ({ wait }?: { wait?: number }): this
+
+    alias (as: string): this
+    elements: EntityElements
+
+
+    // Not yet public
+    // fullJoin (other: string, as: string) : this
+    // leftJoin (other: string, as: string) : this
+    // 	rightJoin (other: string, as: string) : this
+    // 	innerJoin (other: string, as: string) : this
+    // 	join (other: string, as: string, kind?: string) : this
+    // on : TaggedTemplateQueryPart<this>
+    //   & ((...expr : string[]) => this)
+    //   & ((predicate:object) => this)
+
+    SELECT: CQN.SELECT['SELECT'] & {
+        forUpdate?: { wait: number },
+        forShareLock?: { wait: number },
+        search?: CQN.predicate,
+        count?: boolean,
+    }
+
+}
+
+declare type SELECT_from =
+// tagged template
+TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
+&
+// calling with class
+(<T extends ArrayConstructable<any>>
+(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
+=> Awaitable<SELECT_3<T>, InstanceType<T>>)
+&
+(<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
+// calling with definition
+& ((entity: Target, primaryKey?: PK, projection?: Projection<unknown>) => SELECT_3<any>)
+// 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>)
+// 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>>(
+entityType: T,
+projection?: Projection<InstanceType<T>>
+) => Awaitable<SELECT_3<PluralType<T>>, PluralType<T>>)
+& (<T extends Constructable<any>>(
+entityType: T,
+primaryKey: PK,
+projection?: Projection<InstanceType<T>>
+) => Awaitable<SELECT_3<PluralType<T>>, PluralType<T>>)
+
+declare type SELECT_one =
+TaggedTemplateQueryPart<Awaitable<SELECT_3<unknown>, InstanceType<any>>>
+&
+// calling with class
+(<T extends ArrayConstructable<any>>
+(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
+=> Awaitable<SELECT_3<SingularType<T>>, SingularType<T>>)
+&
+(<T extends ArrayConstructable<any>>
+(entityType: T, primaryKey: PK, projection?: Projection<QLExtensions<SingularType<T>>>)
+=> Awaitable<SELECT_3<SingularType<T>>, SingularType<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>)
+
+/**
+ 	 * 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?: {
+    service?: string,
+    from?: '*' | 'all' | string,
+    [key: string]: any,
+}) => Promise<cds_services> & cds_serve_fluent;
+
+/**
+ 	 * The default bootstrap function as loaded from server.js
+ 	 */
+export declare const server: Function;
+
+/**
+ * Class cds.Service
+ * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
+ */
+export declare class Service extends QueryAPI {
+
+    constructor (
+    name?: string,
+    model?: csn.CSN,
+    options?: {
+        kind: string,
+        impl: string | ServiceImpl,
+    }
+    )
+
+    /**
+     * The kind of the service
+     */
+    kind: string
+
+    /**
+     * The name of the service
+     */
+    name: string
+
+    /**
+     * 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
+
+    /**
+     * 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>
+
+    /**
+     * 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>
+
+    /**
+     * 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>
+
+    /**
+     * 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>
+
+    /**
+     * Acts like a parameter-less constructor. Ensure to call `await super.init()` to have the base class’s handlers added.
+     * You may register own handlers before the base class’s ones, to intercept requests before the default handlers snap in.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#srv-init)
+     */
+    init (): Promise<void>
+
+    /**
+     * Constructs and emits an asynchronous event.
+     * @see [capire docs](https://cap.cloud.sap/docs/core-services#srv-emit-event)
+     */
+    emit: {
+        <T = any>(details: { event: types.event, data?: object, headers?: object }): Promise<T>,
+        <T = any>(event: types.event, data?: object, headers?: object): Promise<T>,
+    }
+
+    /**
+     * Constructs and sends a synchronous request.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#srv-send-request)
+     */
+    send: {
+        <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: { 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>,
+    }
+
+    /**
+     * Constructs and sends a GET request.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
+     */
+    get<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
+    /**
+     * Constructs and sends a POST request.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
+     */
+    post<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
+    /**
+     * Constructs and sends a PUT request.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
+     */
+    put<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
+    /**
+     * Constructs and sends a PATCH request.
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
+     */
+    patch<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
+    /**
+     * Constructs and sends a DELETE request.
+     */
+    delete: {
+        <T = any>(entityOrPath: types.target, data?: object): DELETE_3<T>,
+        <T extends ArrayConstructable>(entity: T, key?: Key): DELETE_3<T>,
+        <T>(entity: linked_2.Definition | string, key?: Key): DELETE_3<T>,
+    }
+
+    // The central method to dispatch events
+    dispatch (msg: types.event): Promise<any>
+
+    // FIXME: not yet documented, will come in future version
+    // disconnect (tenant?: string): Promise<void>
+
+    // Provider API
+    prepend (fn: ServiceImpl): this
+
+    on<T extends ArrayConstructable>(eve: types.event, entity: T, handler: CRUDEventHandler.On<InstanceType<T>>): this
+    on<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.On<Array<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
+    on (eve: types.event, handler: OnEventHandler): this
+    on (eve: 'error', handler: OnErrorHandler): this
+
+    // onSucceeded (eve: types.Events, entity: types.Target, handler: types.EventHandler): this
+    // onSucceeded (eve: types.Events, handler: types.EventHandler): this
+    // onFailed (eve: types.Events, entity: types.Target, handler: types.EventHandler): this
+    // onFailed (eve: types.Events, handler: types.EventHandler): this
+    before<T extends ArrayConstructable>(eve: types.event, entity: T, handler: CRUDEventHandler.Before<InstanceType<T>>): this
+    before<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.Before<Array<InstanceType<T>>>): this
+    before (eve: types.event, entity: types.target, handler: EventHandler): this
+    before (eve: types.event, handler: EventHandler): this
+
+    // order relevant:
+    // (2) check if T is arrayable -> use T directly
+    // (3) check if T is scalar -> wrap into array
+    // this streamlines that in _most_ cases, handlers will receive an array.
+    // _Except_ for after.read handlers (1), which will change its inflection based on T.
+    after<T extends ArrayConstructable>(event: 'READ' | '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<InstanceType<T>>): this
+    after<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.After<Array<InstanceType<T>>>): this
+    after (eve: types.event, entity: types.target, handler: ResultsHandler): this
+    after (eve: types.event, handler: ResultsHandler): this
+
+    reject (eves: types.event, ...entity: types.target[]): this
+
+}
+
+/**
+ 	 * 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 declare type service = {
+
+    /**
+     	 * Dummy wrapper for service implementation functions.
+     	 * Use that in modules to get IntelliSense.
+     	 */
+    impl (impl: ServiceImpl): typeof impl,
+    // impl <T> (srv:T, impl: (  _cds: T, srv: (T) ) => any) : typeof impl
+
+    /**
+     	 * Array of all services constructed.
+     	 */
+    providers: Service[],
+}
+
+/**
+ * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect#cds-service)
+ */
+export declare interface service_ extends csn.service {}
+
+export declare class service_ extends context_ {
+    is_service: true
+    get entities (): Definitions<entity>
+    get types (): Definitions<type>
+    get events (): Definitions<event>
+    get actions (): Definitions<action>
+
+    /**
+     * @deprecated use `.actions` instead
+     */
+    get operations (): Definitions<action>
+
+    /**
+     * @alpha
+     * not public yet
+     */
+    get protocols (): { [protocol in Protocol]?: boolean | undefined }
+}
+
+declare interface service_2 extends any__2 { }
+
+export declare interface ServiceImpl {
+    (this: Service, srv: Service): any
+}
+
+/**
+ 	 * Dictionary of all services constructed and/or connected.
+ 	 */
+export declare const services: cds_services;
+
+declare type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+
+/** @private */
+export declare 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 declare class SpawnEventEmitter {
+
+    on<U extends keyof SpawnEvents>(
+    event: U, listener: SpawnEvents[U]
+    ): this
+
+    emit<U extends keyof SpawnEvents>(
+    event: U, ...args: Parameters<SpawnEvents[U]>
+    ): boolean
+    timer: any
+
+}
+
+export declare interface SpawnEvents {
+    succeeded: (res: any) => void
+    failed: (error: any) => void
+    done: () => void
+}
+
+export declare type SpawnOptions = {
+    [key: string]: any,
+    every?: number,
+    after?: number,
+}
+
+export declare type SQL = string
+
+declare 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>>)
+& SELECT_from // as it is not directly quantified, ...
+& SELECT_one
+
+export declare const stream: Service['stream'];
+
+export declare const string: typeof string_;
+
+declare class string_ extends scalar { }
+
+declare class String_2 extends string { }
+export { String_2 as 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 declare 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 {
+
+    /**
+     * References to definitions to be included.
+     * Not available after extensions have been applied.
+     */
+    includes?: FQN[]
+    elements: { [name: string]: Element }
+}
+
+/**
+ * Adds the ability for subqueries to structured properties.
+ * The final result of each subquery will be the property itself:
+ * `Book.title` == `Subqueryable<Book>.title()`
+ */
+declare type Subqueryable<T> = T extends Primitive	? unknown
+// composition of many/ association to many
+: T extends readonly unknown[] ? {
+
+    /**
+     	 * @example
+     	 * ```js
+     	 * SELECT.from(Books, b => b.author)
+     	 * ```
+     	 * means: "select all books and project each book's author"
+     	 *
+     	 * whereas
+     	 * ```js
+     	 * SELECT.from(Books, b => b.author(a => a.ID))
+     	 * ```
+     	 * means: "select all books, subselect each book's author's ID
+     	 *
+     	 * Note that you do not need to return anything from these subqueries.
+     	 */
+    (fn: ((a: QLExtensions<T[number]>) => any) | '*'): T[number],
+}
+// composition of one/ association to one
+: {
+
+    /**
+     	 * @example
+     	 * ```js
+     	 * SELECT.from(Books, b => b.author)
+     	 * ```
+     	 * means: "select all books and project each book's author"
+     	 *
+     	 * whereas
+     	 * ```js
+     	 * SELECT.from(Books, b => b.author(a => a.ID))
+     	 * ```
+     	 * means: "select all books, subselect each book's author's ID
+     	 *
+     	 * Note that you do not need to return anything from these subqueries.
+     	 */
+    (fn: ((a: QLExtensions<T>) => any) | '*'): T,
+}
+
+declare type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params: unknown[]) => T
+
+/**
+ * Target for any QL operation
+ */
+declare type Target = linked_2.entity | Definition_2 | string
+
+declare class Test extends Axios {
+
+    test: Test
+
+    run (cmd: string, ...args: string[]): this
+
+    in (...paths: string[]): this
+
+    silent (): this
+
+    /**
+     * @deprecated Server log is shown by default. Use `log()` to get control over it.
+     */
+    verbose (v: boolean): this
+
+    get chai (): typeof chai
+
+    get expect (): typeof chai.expect
+
+    get assert (): typeof chai.assert
+
+    get data (): DataUtil
+
+    get cds (): _cds_2
+
+    log (): {
+        output: string,
+        clear(): void,
+        release(): void,
+    }
+
+    then (r: (args: { server: 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
+    //   ? Spy<TArgs, TReturnValue>
+    //   : Spy;
+
+}
+
+export declare const test: {
+    Test: typeof Test,
+
+    /**
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/cds-test#class-cds-test-test)
+     */
+    (dirname: string): Test,
+
+    /**
+     * @see [capire docs](https://cap.cloud.sap/docs/node.js/cds-test#class-cds-test-test)
+     */
+    (command: string, ...args: string[]): Test,
+
+    in (dirname: string): Test,
+};
+
+export declare class Time extends date { }
+
+export declare class TimeStamp extends DateTime { }
+
+/**
+ * DO NOT USE
+ * @internal
+ */
+export declare type _TODO = any
+
+export declare interface Transaction extends Service {
+    commit(): Promise<void>
+    rollback(): Promise<void>
+}
+
+export declare const transaction: Service['transaction'];
+
+/**
+ * Starts or joins a transaction
+ * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx)
+ */
+export declare 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'> {
+    items: type
+}
+
+export declare class type<K extends kinds = 'type'> extends any_<K> { }
+
+declare interface type_2 extends any__2 {
+    type?: FQN
+    items?: type_2
+}
+
+export declare type TypedRequest<T> = Omit<Request_2, 'data'> & { data: T }
+
+export declare 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 declare class UInt8 extends Integer { }
+
+export declare const unboxed: (service: Service) => Service;
+
+declare 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>
+
+declare type Unwrap<T> = T extends ArrayConstructable
+? SingularType<T>
+: T extends Array<infer U>
+? U
+: T
+
+export declare const update: Service['update'];
+
+declare 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 {
+
+    // cds-typer plural
+    static entity<T extends ArrayConstructable<any>> (entity: T, primaryKey?: PK): UPDATE_3<SingularType<T>>
+
+    static entity (entity: Target, primaryKey?: PK): UPDATE_3<any>
+
+    static entity<T> (entity: Constructable<T>, primaryKey?: PK): UPDATE_3<T>
+
+    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>
+    & ((data: object) => this);
+
+    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']
+
+}
+
+declare type UPSERT_2 = { UPSERT: {
+        into: ref | name,
+        columns: string[],
+        entries: data[],
+        values: primitive[],
+        rows: primitive[][],
+    }, }
+export { UPSERT_2 as UPSERT }
+
+declare 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)
+
+    data (block: (e: T) => void): this
+
+    entries (...entries: object[]): this
+
+    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']
+
+}
+
+/**
+ * Represents the user in a given context.
+ * @see [capire docs](https://cap.cloud.sap/docs/node.js/authentication#cds-user)
+ */
+export declare class User {
+
+    constructor (obj?: string | { id: string, attr: Record<string, string>, roles: Array<string> | Record<string, string> } | User)
+    id: string
+
+    /**
+     * @deprecated Use https://cap.cloud.sap/docs/node.js/events#locale instead
+     */
+    locale: string
+
+    /**
+     * @deprecated Use https://cap.cloud.sap/docs/node.js/events#tenant instead
+     */
+    tenant: string | undefined
+
+    attr: Record<string, string>
+
+    roles: Array<string> | Record<string, string>
+
+    static Privileged: typeof Privileged
+
+    is (role: string): boolean
+
+}
+
+/**
+ * Provides a set of utility functionss
+ */
+export declare const utils: {
+
+    /**
+     	 * Generates a new v4 UUID
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-facade#cds-utils
+     	 */
+    uuid (): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#decodeuri
+     	 */
+    decodeURI(input: string): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#decodeuricomponent
+     	 */
+    decodeURIComponent(input: string): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#local-filename
+     	 */
+    local(filename: string): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#exists-file
+     	 */
+    exist(file: string): boolean,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#isdir-file
+     	 */
+    isdir(file: string): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#isdir-file
+     	 */
+    isfile(file: string): string,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-read-file
+     	 */
+    read(file: string): Promise<Buffer | object>,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-write-data-to-file
+     	 */
+    write: {
+        (data: object): {
+            to(...file: string[]): Promise<ReturnType<typeof fs.promises.writeFile>>,
+        },
+        (file: string, data: object): Promise<ReturnType<typeof fs.promises.writeFile>>,
+    },
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-copy-src-to-dst
+     	 */
+    copy: {
+        (src: string): {
+            to(...dst: string[]): Promise<ReturnType<typeof fs.promises.copyFile>>,
+        },
+        (dst: string, src: string): Promise<ReturnType<typeof fs.promises.copyFile>>,
+    },
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-mkdirp-path
+     	 */
+    mkdirp: (...path: string[]) => Promise<string>,
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rmdir-path
+     	 */
+    rmdir: (...path: string[]) => Promise<ReturnType<typeof 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>>,
+
+
+    /**
+     	 * @see https://cap.cloud.sap/docs/node.js/cds-utils#async-rm-path
+     	 */
+    rm: (...path: string[]) => Promise<ReturnType<typeof fs.promises.rm>>,
+};
+
+export declare class UUID extends string { }
+
+/** @private */
+export declare type val = { val: any }
+
+export declare class Vector extends Binary { }
+
+export declare const version: string;
+
+declare type Visitor = (def: any_, name: string, parent: any_, defs: Definitions) => void
+
+export declare interface WithElements {
+    elements: Definitions<type>
+}
+
+/**
+ * https://stackoverflow.com/a/53229567
+ * @internal
+ */
+declare type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
+
+export declare type XML = string
+
+/** @internal */
+declare 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 }
+
+/** @private */
+export declare type _xpr = (expr | operator) []
+
+export declare type YAML = string
+
+export { }
+
+declare 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']
+  const UPSERT: ql.QL<any>['UPSERT']
+  const UPDATE: ql.QL<any>['UPDATE']
+  const DELETE: ql.QL<any>['DELETE']
+  const CREATE: ql.QL<any>['CREATE']
+  const DROP: ql.QL<any>['DROP']
+
+  // and these allow us to use them as type too, i.e. `const q: SELECT<Book> = ...`
+  type SELECT<T> = ql.SELECT<T>
+  type INSERT<T> = ql.INSERT<T>
+  type UPSERT<T> = ql.UPSERT<T>
+  type UPDATE<T> = ql.UPDATE<T>
+  type DELETE<T> = ql.DELETE<T>
+  type CREATE<T> = ql.CREATE<T>
+  type DROP<T> = ql.DROP<T>
+}