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

package/apis/log.d.ts

@@ -1,164 +0,0 @@
-
-/**
- * Create a new logger, or install a custom log formatter
- */
-export declare const log: LogFactory
-
-/**
- * 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
-
-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?: number, 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
-
-    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 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[]
-}
-
-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
-}
-
-declare enum levels {
-    SILENT = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4, TRACE = 5, SILLY = 5, VERBOSE = 5
-}

package/apis/models.d.ts

@@ -1,171 +0,0 @@
-import { Query as CQN, expr, _xpr } from "./cqn"
-import { LinkedCSN } from "./linked"
-import { CSN } from "./csn"
-import * as cds from './cds'
-
-type _flavor = 'parsed' | 'xtended' | 'inferred'
-type _odata_options = {
-    flavor?: 'v2' | 'v4' | 'w4'| 'x4',
-    version?: 'v2' | 'v4',
-    structs?: boolean,
-    refs?: boolean,
-}
-type _options = {
-    flavor?: _flavor,
-    plain?: boolean,
-    docs?: boolean,
-    names?: string,
-    odata?: _odata_options,
-} | _flavor
-
-type JSON = string
-type YAML = string
-type CDL = string
-type SQL = string
-type XML = string
-type EDM = { $version:string }
-type EDMX = XML
-type filename = string
-
-
-/**
- * The effective CDS model loaded during bootstrapping, which contains all service and entity definitions,
- * including required services.
- */
-export const model : LinkedCSN | undefined  // was ?: LinkedCSN
-
-/**
- * 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 const parse : {
-    /** Shortcut to `cds.parse.cdl()` */
-    (cdl:CDL) : CSN
-    cdl (cdl:CDL) : CSN
-    cql (src:string) : CQN
-    expr (src:string) : expr
-    xpr (src:string) : _xpr
-    ref (src:string) : string[]
-}
-
-/**
- * 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 function get (files: '*' | filename | filename[], o?:_options): Promise<CSN>
-
-/**
- * Shortcut for `cds.get(files, 'inferred')`
- * @param files - filenames of models or if folder containing models
- */
-export function load (files: '*' | filename | filename[], o?:_options): Promise<CSN>
-
-
-/**
- * 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 function resolve (files: '*' | filename | filename[]): filename[] | undefined
-
-/**
- * Turns the given plain CSN model into a linked model
- * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect)
- */
-declare const linked: (model: CSN) => LinkedCSN
-
-/**
- * Turns the given plain CSN model into a reflected model
- * @see [capire](https://cap.cloud.sap/docs/node.js/cds-reflect)
- */
-export const reflect: (model: CSN) => LinkedCSN
-
-/**
-* 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 const compile: {
-   /** Shortcut for `cds.compile.to.csn()` */
-   cdl (model:CDL, o?:_options) : CSN,
-
-   for: {
-       odata (model:CSN, o?:_options) : CSN
-       sql (model:CSN, o?:_options) : CSN
-   },
-   to: {
-       parsed:{
-           csn (files:filename[], o?:_options) : Promise<CSN>
-           csn (model:CDL, o?:_options) : CSN
-       }
-       xtended:{
-           csn (files:filename[], o?:_options) : Promise<CSN>
-           csn (model:CDL, o?:_options) : CSN
-       }
-       inferred:{
-           csn (files:filename[], o?:_options) : Promise<CSN>
-           csn (model:CDL, o?:_options) : CSN
-       }
-       csn (files:filename[], o?:_options) : Promise<CSN>
-       csn (model:CDL, o?:_options) : CSN
-       yml (model:CSN, o?:_options) : YAML
-       yaml (model:CSN, o?:_options) : YAML
-       json (model:CSN, o?:_options) : JSON
-       sql (model:CSN, o?:_options) : SQL[]
-       cdl (model:CSN, o?:_options) : CDL | Iterable<[CDL,{file:filename}]>
-       edm (model:CSN, o?:_options|_odata_options) : EDM | string
-       edmx (model:CSN, o?:_options|_odata_options) : EDMX | Iterable<[EDMX,{file:filename}]>
-       hdbcds (model:CSN, o?:_options) : SQL | Iterable<[SQL,{file:filename}]>
-       hdbtable (model:CSN, o?:_options) : SQL | Iterable<[SQL,{file:filename}]>
-   }
-
-   /** Fluent API variant */
-   (model: CSN | CDL) : {
-       for: {
-           odata (o?:_options) : CSN
-           sql (o?:_options) : CSN
-       },
-       to: {
-           parsed:{ csn (o?:_options) : CSN }
-           xtended:{ csn (o?:_options) : CSN }
-           inferred:{ csn (o?:_options) : CSN }
-           csn (o?:_options) : CSN
-           yml (o?:_options) : YAML
-           yaml (o?:_options) : YAML
-           json (o?:_options) : JSON
-           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>
-           sql (o?:_options) : Promise<CSN>
-       },
-       to: {
-           parsed:{ csn (o?:_options) : Promise <CSN> }
-           xtended:{ csn (o?:_options) : Promise <CSN> }
-           inferred:{ csn (o?:_options) : Promise <CSN> }
-           csn (o?:_options) : Promise <CSN>
-           yml (o?:_options) : Promise <YAML>
-           yaml (o?:_options) : Promise <YAML>
-           json (o?:_options) : Promise <JSON>
-           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}]>>
-       }
-   }
-}

package/apis/ql.d.ts

@@ -1,327 +0,0 @@
-import { CSN, Definition, EntityElements } from "./csn"
-import * as CQN from "./cqn"
-import { Constructable, ArrayConstructable, SingularType } from "./internal/inference"
-import { LinkedEntity } from "./linked"
-import { ref, column_expr } from './cqn'
-
-export type Query = CQN.Query
-
-export class ConstructedQuery {
-	then(_resolved:(x:any)=>any, _rejected:(e:Error)=>any) : any
-}
-
-
-export type PK = number | string | object
-
-
-type Primitive = string | number | boolean | Date
-
-// don't wrap QLExtensions in more QLExtensions (indirection to work around recursive definition)
-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.
-*/
-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>>
-
-/**
- * Adds the ability for subqueries to structured properties.
- * The final result of each subquery will be the property itself:
- * `Book.title` == `Subqueryable<Book>.title()`
- */
-type Subqueryable<T> =
-T extends Primitive	? {}
-// 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
-}
-;
-
-
-// Alias for projections
-// https://cap.cloud.sap/docs/node.js/cds-ql?q=projection#projection-functions
-//export type Projection<T> = (e:T)=>void
-export type Projection<T> = (e:QLExtensions<T extends ArrayConstructable ?  SingularType<T> : T>)=>void
-// Type for query pieces that can either be chained to build more complex queries or
-// awaited to materialise the result:
-// `Awaitable<SELECT<Book>, Book> = SELECT<Book> & Promise<Book>`
-//
-// While the benefit is probably not immediately obvious as we don't exactly
-// save a lot of typing over explicitly writing `SELECT<Book> & Promise<Book>`,
-// it makes the semantics more explicit. Also sets us up for when TypeScript ever
-// improves their generics to support:
-//
-// `Awaitable<T> = T extends unknown<infer I> ? (T & Promise<I>) : never`
-// (at the time of writing, infering the first generic parameter of ANY type
-// does not seem to be possible.)
-export type Awaitable<T, I> = T & Promise<I>
-
-// all the functionality of an instance of SELECT, but directly callable:
-// new SELECT(...).(...) == SELECT(...)
-export type StaticSELECT<T> = typeof SELECT
-	& ((...columns: (T extends ArrayConstructable<any> ? keyof SingularType<T> : keyof T)[]) => SELECT<T>)
-	& ((...columns:string[]) => SELECT<T>)
-	& ((columns:string[]) => SELECT<T>)
-	& (TaggedTemplateQueryPart<SELECT<T>>)
-	& SELECT_one // as it is not directly quantified, ...
-	& SELECT_from // ...we should expect both a scalar and a list
-
-declare class QL<T> {
-	SELECT : StaticSELECT<T>
-	INSERT : typeof INSERT
-		& ((...entries:object[]) => INSERT<any>) & ((entries:object[]) => INSERT<any>)
-	UPSERT: typeof UPSERT
-		& ((...entries:object[]) => UPSERT<any>) & ((entries:object[]) => UPSERT<any>)
-	UPDATE : typeof UPDATE
-		& typeof UPDATE.entity
-	DELETE : typeof DELETE
-	    & ((...entries:object[]) => DELETE<any>) & ((entries:object[]) => DELETE<any>)
-	CREATE : typeof CREATE
-	DROP : typeof DROP
-}
-
-// used as a catch-all type for using tagged template strings: SELECT `foo`. from `bar` etc.
-// the resulting signatures are actually not very strongly typed, but they at least accept template strings
-// when run in strict mode.
-// This signature has to be added to a method as intersection type.
-// Defining overloads with it will override preceding signatures and the other way around.
-type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params: unknown[]) => T
-
-export class SELECT<T> extends ConstructedQuery {
-	static one : SELECT_one & { from: SELECT_one }
-	static distinct : typeof SELECT
-    static from : SELECT_from
-	from: SELECT_from & TaggedTemplateQueryPart<this>
-		& ((entity: Definition | string, 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
-	}
-}
-
-
-type SELECT_one =
-TaggedTemplateQueryPart<Awaitable<SELECT<unknown>, InstanceType<any>>>
-&
-// calling with class
-	(<T extends ArrayConstructable<any>>
-	(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
-	=> Awaitable<SELECT<SingularType<T>>, SingularType<T>>)
-&
-	(<T extends ArrayConstructable<any>>
-	(entityType: T, primaryKey : PK, projection?: Projection<QLExtensions<SingularType<T>>>)
-	=> Awaitable<SELECT<SingularType<T>>, SingularType<T>>)
-
-& ((entity: Definition | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
-& ((entity: LinkedEntity | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
-& (<T> (entity: T[], projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
-& (<T> (entity: T[], primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
-& (<T> (entity: {new():T}, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
-& (<T> (entity: {new():T}, primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
-& ((subject: ref) => SELECT<any>)
-
-type SELECT_from =
-// tagged template
-	TaggedTemplateQueryPart<Awaitable<SELECT<unknown>, InstanceType<any>>>
-&
-// calling with class
-	(<T extends ArrayConstructable<any>>
-	(entityType: T, projection?: Projection<QLExtensions<SingularType<T>>>)
-	=> Awaitable<SELECT<T>, InstanceType<T>>)
-&
-	(<T extends ArrayConstructable<any>>
-	(entityType: T, primaryKey : PK, projection?: Projection<SingularType<T>>)
-	=> Awaitable<SELECT<SingularType<T>>, InstanceType<SingularType<T>>>)  // when specifying a key, we expect a single element as result
-// calling with definition
-& ((entity: Definition | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
-& ((entity: LinkedEntity | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
-// calling with concrete list
-& (<T> (entity: T[], projection? : Projection<T>) => SELECT<T> & Promise<T[]>)
-& (<T> (entity: T[], primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
-& ((subject: ref) => SELECT<any>)
-
-export class INSERT<T> extends ConstructedQuery {
-	static into : (<T extends ArrayConstructable<any>> (entity:T, entries? : object | object[]) => INSERT<SingularType<T>>)
-		& (TaggedTemplateQueryPart<INSERT<unknown>>)
-		& ((entity : Definition | string, entries? : object | object[]) => INSERT<any>)
-		& ((entity : LinkedEntity | string, entries? : object | object[]) => INSERT<any>)
-		& (<T> (entity:Constructable<T>, entries? : object | object[]) => INSERT<T>)
-		& (<T> (entity:T, entries? : T | object | object[]) => INSERT<T>)
-
-	into: (<T extends ArrayConstructable> (entity:T) => this)
-		& TaggedTemplateQueryPart<this>
-		& ((entity : Definition | string) => 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<T>): this
-	INSERT : CQN.INSERT["INSERT"]
-}
-
-
-export class UPSERT<T> extends ConstructedQuery {
-	static into : (<T extends ArrayConstructable<any>> (entity:T, entries? : object | object[]) => UPSERT<SingularType<T>>)
-		& (TaggedTemplateQueryPart<UPSERT<unknown>>)
-		& ((entity : Definition | string, entries? : object | object[]) => UPSERT<any>)
-		& ((entity : LinkedEntity | string, entries? : object | object[]) => UPSERT<any>)
-		& (<T> (entity:Constructable<T>, entries? : object | object[]) => UPSERT<T>)
-		& (<T> (entity:T, entries? : T | object | object[]) => UPSERT<T>)
-
-	into: (<T extends ArrayConstructable> (entity:T) => this)
-		& TaggedTemplateQueryPart<this>
-		& ((entity : Definition | string) => 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"]
-}
-
-
-
-export class DELETE<T> extends ConstructedQuery {
-	static from:
-TaggedTemplateQueryPart<Awaitable<SELECT<unknown>, InstanceType<any>>>
-	 	& ((entity : Definition | string | ArrayConstructable, primaryKey? : PK) => DELETE<any>)
-	 	& ((entity : LinkedEntity | string | ArrayConstructable, primaryKey? : PK) => DELETE<any>)
-		& ((subject: ref) => DELETE<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 class UPDATE<T> extends ConstructedQuery {
-	// cds-typer plural
-	static entity <T extends ArrayConstructable<any>> (entity:T, primaryKey? : PK) : UPDATE<SingularType<T>>
-
-	static entity (entity : Definition | string, primaryKey? : PK) : UPDATE<any>
-	static entity (entity : LinkedEntity | string, primaryKey? : PK) : UPDATE<any>
-	static entity <T> (entity:Constructable<T>, primaryKey? : PK) : UPDATE<T>
-	static entity <T> (entity:T, primaryKey? : PK) : UPDATE<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"]
-}
-
-export class CREATE<T> extends ConstructedQuery {
-	static entity (entity : Definition | string) : CREATE<any>
-	static entity (entity : LinkedEntity | string) : CREATE<any>
-	CREATE : CQN.CREATE["CREATE"]
-}
-
-export class DROP<T> extends ConstructedQuery {
-	static entity (entity : Definition | string) : DROP<any>
-	static entity (entity : LinkedEntity | string) : DROP<any>
-	DROP : CQN.DROP["DROP"]
-}