@olympeio/runtime-node 9.10.4 → 9.11.0

package/types/cloud.d.ts

@@ -1,1726 +0,0 @@
-// *********************************************
-//
-//     Olympe Data cloud objects Public API
-//
-// *********************************************
-
-// @ts-ignore
-import {Observable} from 'rxjs';
-import {Readable} from 'stream';
-import {Context, CloudObject, Relation, Property, InstanceOrTag, Class} from "./base";
-import {Brick, BrickContext} from './runtime';
-import {Color} from "./utils";
-
-// --------------------------
-// -- Primitive data types --
-// --------------------------
-/**
- * A property model defines a property of a data type.
- * A property is defined by its type and the model it defines a property for.
- * */
-export class PropertyModel extends CloudObject {
-    /**
-     * Relation from the property model to the data type (model)
-     * to which that property is attached.
-     *
-     * Example:
-     *
-     * ` myNumberPropertyModel --definingModelRel-> myDataTypeObject`
-     */
-    static definingModelRel: Relation<PropertyModel, CloudObject>;
-
-    /**
-     * Relation from the `PropertyModel` to its type.
-     *
-     * Example :
-     *
-     * `myNumberPropertyModel --typeRel-> Number`
-     */
-    static typeRel: Relation<PropertyModel, CloudObject>;
-}
-
-export type FollowRule = Property<number>;
-
-/**
- * A relation model defines a relation between two data types.
- * It defines what data types is the origin and the destination of the relation.
- *
- * It also defines follow rules properties on the relation.
- * */
-export class RelationModel extends CloudObject {
-    /**
-     * Relation from the origin data type to the RelationModel
-     * */
-    static originModelRel: Relation<RelationModel, CloudObject>;
-    /**
-     * Relation from a RelationModel to the destination data type
-     * */
-    static destinationModelRel: Relation<RelationModel, CloudObject>;
-    /**
-     * Property for the *dump* follow rule
-     */
-    static dumpFollowRuleProp: FollowRule;
-    /**
-     * Property for the *delete* follow rule
-     */
-    static deleteFollowRuleProp: FollowRule;
-    /**
-     * Property for the *runtime* follow rule
-     */
-    static runtimeFollowRuleProp: FollowRule;
-}
-
-/**
- * StringModel represents a {@apilink PropertyModel} for a string property of a data type.
- */
-export class StringModel extends CloudObject {
-    static valueProp: Property<string>;
-}
-
-/**
- * NumberModel represents a {@apilink PropertyModel} for a number property of a data type.
- */
-export class NumberModel extends CloudObject {
-    static valueProp: Property<number>;
-}
-
-/**
- * BooleanModel represents a {@apilink PropertyModel} for a boolean property of a data type.
- */
-export class BooleanModel extends CloudObject {
-    static valueProp: Property<boolean>;
-}
-
-/**
- * DatetimeModel represents a {@apilink PropertyModel} for a datetime property of a data type.
- */
-export class DatetimeModel extends CloudObject {
-    static valueProp: Property<Date>;
-}
-
-/**
- * ColorModel represents a {@apilink PropertyModel} for a color property of a data type.
- */
-export class ColorModel extends CloudObject {
-    static valueProp: Property<Color>;
-}
-
-/**
- * File is the main class used to create business objects with a binary/string data content.
- * It is a Data Type so can be extended and associated to a data source.
- */
-export class File extends CloudObject {
-
-    /**
-     * @deprecated because conflict with {@apilink CloudObject.nameProp}. Use {@apilink File.fileNameProp} instead.
-     */
-    static nameProp: Property<string>;
-    static fileNameProp: Property<string>;
-    static creationDateProp: Property<Date>;
-    static modificationDateProp: Property<Date>;
-    static mimeTypeProp: Property<string>;
-    static urlProp: Property<string>;
-
-    /**
-     * Set the binary content of a specified file
-     * @param transaction transaction in which to create the file
-     * @param file tag of the file
-     * @param name file name
-     * @param content byte content of the file
-     * @param mimeType optional mime type of the file
-     */
-    static setContent(transaction: Transaction, file: InstanceOrTag, name: string, content: Uint8Array | ArrayBuffer, mimeType?: string): void;
-
-    /**
-     * Set the content of a `File` from a specified URL
-     * @param transaction transaction in which to create the file
-     * @param file tag of the file
-     * @param name filename
-     * @param url url to retrieve content from
-     * @param mimeType optional mime type of the file
-     */
-    static setURLContent(transaction: Transaction, file: InstanceOrTag, name: string, url: string, mimeType?: string): void;
-
-    /**
-     * @deprecated Please use {@apilink File.setContent}
-     * Create a `File` from its content
-     *
-     * @param transaction transaction in which to create the file
-     * @param name filename
-     * @param content byte content of the file
-     * @param mimeType optional mime type of the file
-     * @param source optional source where file will be stored ({@apilink {PredefinedDataSource}} or DBConnector tag)
-     * @param tag optional tag for the file
-     * @return tag string of the file
-     */
-    static createFromContent(transaction: Transaction, name: string, content: Uint8Array | ArrayBuffer, mimeType?: string, source?: Source, tag?: string): string;
-
-    /**
-     * @deprecated Please use {@apilink File.setURLContent}
-     * Create a `File` from a specified URL
-     * @param transaction transaction in which to create the file
-     * @param name filename
-     * @param url url to retrieve content from
-     * @param mimeType optional mime type of the file
-     * @param source optional source where file will be stored ({@apilink {PredefinedDataSource}} or DBConnector tag)
-     * @param tag optional tag for the file
-     * @return tag string of the file
-     */
-    static createFromURL(transaction: Transaction, name: string, url: string, mimeType?: string, source?: Source, tag?: string): string;
-
-    /**
-     * Gets the file content as an ArrayBuffer.
-     *
-     * @deprecated consider using the new `getContentAsBinary` method returning a Promise instead
-     * @param onSuccess (deprecated) callback to execute when byte content has been retrieved successfully
-     * @param onFailure (deprecated) callback to execute when content retrieval has failed
-     */
-    getContentAsBinary(onSuccess: (content: ArrayBuffer) => void, onFailure?: (errMsg: string) => void);
-
-    /**
-     * Gets the file content as an ArrayBuffer.
-     *
-     * @return promise resolving with the content as a byte array
-     */
-    getContentAsBinary():Promise<ArrayBuffer>;
-
-    /**
-     * Get the content of this file and returns it as an UTF-8 string.
-     * **Note:** this method should be used only when the file is a text file.
-     *
-     * @deprecated consider using the new `getContentAsString` method returning a Promise instead
-     * @param onSuccess (deprecated) callback to execute when string content has been retrieved successfully
-     * @param onFailure (deprecated) callback to execute when content retrieval has failed
-     */
-    getContentAsString(onSuccess: (content: string) => void, onFailure?: (errMsg: string) => void);
-
-    /**
-     * Get the content of this file and returns it as an UTF-8 string.
-     * **Note:** this method should be used only when the file is a text file.
-     *
-     * @return promise resolving with the content as a string
-     */
-    getContentAsString(): Promise<string>;
-
-    /**
-     * Gets the URL that gives direct access to the file content:
-     * - For files that are external to Olympe, gives the normal URL
-     * - For the files stored by Olympe, provides a dataURL, with the content embedded in Base64
-     *
-     * @deprecated consider using the new `getContentUrl` method returning a Promise instead
-     * @param onSuccess (deprecated) callback to execute when content has been retrieved successfully
-     * @param onFailure (deprecated) callback to execute when content retrieval has failed
-     */
-    getContentUrl(onSuccess: (content: string) => void, onFailure?: () => void);
-
-    /**
-     * Gets the URL that gives direct access to the file content:
-     * - For files that are external to Olympe, gives the normal URL
-     * - For the files stored by Olympe, provides a dataURL, with the content embedded in Base64
-     *
-     * @return promise resolving with the content as a string
-     */
-    getContentUrl(): Promise<string>;
-
-    /**
-     * Save this file with specified name
-     *
-     * @param name filename
-     */
-    saveAs(name: string): void;
-}
-
-/**
- * User object for authentication purposes
- */
-export class User extends CloudObject {
-    static loginProp: Property<string>;
-    static saltProp: Property<string>;
-    static verifierProp: Property<string>;
-    static SAMLnameIdProp: Property<string>;
-}
-
-/**
- * An Enum is an ordered list of string key-values mappings
- */
-export class Enum extends CloudObject {
-    /**
-     * Create an empty `Enum?`  without any value
-     *
-     * See {@apilink EnumValue.createValue} to create values for an Enum.
-     *
-     * @param transaction transaction in which to create the Enum
-     * @param name optional name of the Enum
-     * @return string tag of the Enum object
-     */
-    create(transaction: Transaction, name?: string): string;
-
-    /**
-     * Get the values defined for this `Enum`
-     */
-    getValues(): QueryResult<EnumValue>;
-}
-
-/**
- * An `EnumValue` is a single value part of an `Enum`.
- * It has a `string` name, a rank (its position in the Enum list).
- *
- * The values for `EnumValue` are always stringified.
- */
-export class EnumValue extends CloudObject {
-    /**
-     * Add a `EnumValue` to a specified `Enum`
-     *
-     * @param transaction transaction in which to add the EnumValue to the Enum
-     * @param enumModel `EnumModel` containing the specified `EnumValue`
-     * @param value value of the `EnumValue`
-     * @param name name of the `EnumValue`
-     * @param rank position of the `EnumValue` in the `Enum`
-     */
-    static createValue(transaction: Transaction, enumModel: InstanceOrTag, value: string, name?: string, rank?: number): string;
-
-    /**
-     * Name property for an EnumValue
-     */
-    static nameProp: Property<string>;
-    /**
-     * Value property for an EnumValue
-     */
-    static valueProp: Property<string>;
-    /**
-     * Rank property for an EnumValue
-     */
-    static rankProp: Property<number>;
-}
-
-// -------------------------
-// -- Workflow data types --
-// -------------------------
-
-/**
- * A `Workflow` is a sequence of {@apilink WorkflowState} in which instances of a model goes through.
- * {@apilink WorkflowState} are linked by {@apilink WorkflowTransition} that can have an optional _process function_.
- * The `Workflow` also historize the {@apilink WorkflowState} of the instance and optionally serialize the object itself in a {@apilink WorkflowObjectState}.
- */
-export class Workflow extends CloudObject {
-    /** Is the instance serialization enabled or not */
-    static serializationEnabledProp: Property<boolean>;
-    /** The model to which the `Workflow` is associated */
-    static dataTypeRel: Relation<Workflow, CloudObject>;
-    /** The {@apilink WorkflowState} that are in the `Workflow` */
-    static statesRel: Relation<Workflow, WorkflowState>;
-    /** The initial {@apilink WorkflowState} of the `Workflow` */
-    static initialStateRel: Relation<Workflow, WorkflowState>;
-}
-
-/**
- * A `WorkflowState` defines a state in a {@apilink Workflow}.
- */
-export class WorkflowState extends CloudObject { /* empty */ }
-
-/**
- * A `WorkflowTransition` defines a transition between 2 {@apilink WorkflowState}.
- * It has a direction (`fromStateRel` to `toStateRel`) and can have an optional _process function_.
- * The _process function_ (`processRefProp`) is automatically triggered when the transition occurs.
- */
-export class WorkflowTransition extends CloudObject {
-    /**
-     * The `WorkflowTransition` optional _process function_.
-     * It has this signature: (ControlFlow, CloudObject, User, Map) -> (ControlFlow, ErrorFlow)
-     */
-    static processRefProp: Property<Brick>;
-    /** The {@apilink WorkflowState} from which this transition starts */
-    static fromStateRel: Relation<WorkflowTransition, WorkflowState>;
-    /** The {@apilink WorkflowState} to which this transition ends */
-    static toStateRel: Relation<WorkflowTransition, WorkflowState>;
-}
-
-/**
- * A `WorkflowObjectState` represents the state of an instance at a certain point in time.
- * It is automatically created when initializing a {@apilink Workflow} on an instance or when triggering a {@apilink WorkflowTransition}.
- */
-export class WorkflowObjectState extends CloudObject {
-    /** The name of the {@apilink Workflow} associated */
-    static workflowProp: Property<string>;
-    /** The name of the {@apilink WorkflowState} */
-    static stateProp: Property<string>;
-    /** The name (login) of the {@apilink User} */
-    static assigneeProp: Property<string>;
-    /** The point in time of this object state */
-    static dateTimeProp: Property<Date>;
-    /** If the {@apilink Workflow} has serialization enabled, the object's property are saved here in JSON */
-    static serializedObjectProp: Property<string>;
-    /** The related instance this object state represents */
-    static objectRel: Relation<WorkflowObjectState, CloudObject>;
-    /** The related instance this object state represents. This relation only reference the current state */
-    static currentObjectRel: Relation<WorkflowObjectState, CloudObject>;
-}
-
-// -------------------------
-// -- Theme data types --
-// -------------------------
-
-/**
- * Theme object describing the main visual properties used by components
- */
-export class Theme extends CloudObject {
-    static nameProp: Property<string>;
-    static primaryColorProp: Property<string>;
-    static secondaryColorProp: Property<string>;
-    static errorColorProp: Property<string>;
-    static warningColorProp: Property<string>;
-    static infoColorProp: Property<string>;
-    static successColorProp: Property<string>;
-    static fontFamilyProp: Property<string>;
-}
-
-// ---------------------------
-// -- Database transactions --
-// ---------------------------
-
-/**
- * Transactions are the unique way to apply a list of operations to the datacloud.
- * A transaction can be merged into another transaction so that both are executed as a single set of operations.
- *
- * All the operations for a transaction are executed atomically. Either all operations succeed, or none is applied.
- *
- *
- * There are 5 types of basic operations :
- * - Create instance: create a node in the database with specified properties.
- * - Update instance property: update an existing node in the database.
- * - Delete instance: delete a node from the database. Delete only works if all the relations are removed too. Cascade delete can be activated.
- * - Create relation: create a relation of a specific type between 2 existing node.
- * - Delete relation: remove the specified relation between 2 specified nodes.
- *
- * In most cases, we apply the Transactions operations using the "execute()" method. The transaction size is limited but in real-time.
- * It notifies observers of the data in real-time.
- *
- * Larger transactions with big set of operations (batch updates) must be executed using "executeAsLarge()" method. However, no notification will be generated.
- *
- * Callbacks can be registered on transaction using "afterExecution()" method. They are executed once the transaction is applied.
- *
- * Example of transaction:
- *
- * ```javascript
- * const tx = new Transaction(true);
- * const myNewInstanceTag = tx.create(<myModelTag>);
- * tx.update(myNewInstanceTag, <myPropertyTag>, <myPropertyValue>)
- *   .execute()
- *   .then(() => {
- *      // success tx case
- *   })
- *   .catch((err) => {
- *      // error during tx case
- *   })
- * ```
- *
- * Concurrency transactions do not guarantee their execution order.
- */
-export class Transaction {
-
-    /**
-     * Create a new transaction object.
-     *
-     * @param persist if set to `true`, will persist to the data source the objects {@apilink Transaction.create} created in that transaction. (Default = `true`)
-     */
-    constructor(persist?: boolean);
-
-    /**
-     * Get the transaction id attached to this transaction
-     * @return this transaction id
-     */
-    getId(): string;
-
-    // Operations
-    /**
-     * Create a new instance.
-     *
-     * A custom map can specify property values for the instance.
-     *
-     * A source can be the orchestrator ({@apilink {PredefinedDataSource.SERVER}}), local ({@apilink {PredefinedDataSource.SELF}}) or
-     * an external data source (tag of DBConnector). The source is where
-     * the object is persisted and its true value outside local scopes.
-     *
-     * @param model tag of the model of the instance to be created
-     * @param properties custom map from tag to their value for properties of the instance to be created
-     * @param source optional source of the instance
-     * @param tag optional tag of the instance to be created and must be unique
-     * @return  the tag of the instance to be created
-     */
-    create(model: InstanceOrTag, properties?: Map<InstanceOrTag, any>, source?: Source, tag?: string): string;
-
-    /**
-     * Update the property of an instance
-     *
-     * @param instance tag of the instance to be updated
-     * @param property the property to be updated
-     * @param value the value of the property to be updated to
-     * @return this transaction
-     */
-    update<T>(instance: InstanceOrTag, property?: Property<T>, value?: T): this;
-
-    /**
-     * Update multiple properties of a single instance
-     *
-     * @param instance tag of the instance to be updated
-     * @param properties map of properties to update
-     * @return this transaction
-     */
-    multiUpdate(instance: InstanceOrTag, properties: Map<InstanceOrTag, any>): this;
-
-    /**
-     * Delete an instance
-     *
-     * @param instance tag of the instance to be deleted
-     * @return this transaction
-     */
-    delete(instance: InstanceOrTag): this;
-
-    /**
-     * Create relation between two instances
-     *
-     * @param relation tag of the relation to be created
-     * @param from tag of the ORIGIN instance of the relation
-     * @param to tag ofo the DESTINATION instance of the relation
-     * @return this transaction with the create relation operation registered
-     */
-    createRelation(relation: InstanceOrTag, from: InstanceOrTag, to: InstanceOrTag): this;
-
-    /**
-     * Delete a relation between two specified instances.
-     *
-     * The relation is only deleted for the relation parameter direction.
-     *
-     * @param relation tag of the relation to be deleted
-     * @param from origin instance tag
-     * @param to destination instance tag
-     * @return this transaction
-     */
-    deleteRelation(relation: InstanceOrTag, from: InstanceOrTag, to: InstanceOrTag): this;
-
-    /**
-     * Delete any number of the relation starting from specified node.
-     *
-     * The specified node might be the origin or (exclusive) the destination of the relation.
-     *
-     * For the relations :
-     * ```
-     * - a - [rel1] -> b,
-     * - c - [inverseRel(rel1)] -> a,
-     * - a - [rel1] -> d,
-     * - a - [rel2] -> d
-     * ```
-     * `tx.deleteAllRelation(rel1, a)` will remove the first and third relations
-     *
-     * @param relation deleted relation, indicates relation tag *and* direction
-     * @param origin starting node
-     */
-    deleteAllRelations(relation: Relation<any, any>, origin: InstanceOrTag): this;
-
-    /**
-     * Set the specified instance to be persisted or not in this transaction.
-     * Default value of persist is true.
-     *
-     * @param instance the instance to be persisted
-     * @param persist determine if the specified instance should be persisted or not (true by default).
-     * @return this transaction
-     */
-    persist(instance: InstanceOrTag, persist?: boolean): this;
-
-    /**
-     * Change the persistence mode for a single instance in this transaction
-     *
-     * @deprecated use {@apilink Transaction.persist} instead
-     * @param instance the instance to be persisted
-     * @param persist the persisting mode
-     * @return this transaction
-     */
-    persistInstance(instance: InstanceOrTag, persist?: boolean): this;
-
-    /**
-     * Change the source of all instances created in this transaction
-     *
-     * `source` can be specified as :
-     * 1. a predefined source type {@apilink {PredefinedDataSource}}
-     * 2. an external data source (Tag of a `DBConnector`)
-     *
-     * The source of a data object is where the object is persisted.
-     *
-     * By default, the `source` is the default source configured in the project.
-     *
-     * @param source the new source for instances
-     * @return this transaction
-     */
-    setSource(source: Source): this;
-
-    /**
-     * Retrieve the tag of the model of the instance tag
-     * from the created instances in this transaction
-     * or from the local database.
-     *
-     * @param tag the instance to find the model of
-     * @return the tag of the model of the given instance
-     */
-    model(tag: InstanceOrTag): string | null;
-
-    /**
-     * Add all operations of another transaction into this transaction
-     *
-     * @param otherTransaction the other transaction to add operations from
-     * @return this transaction
-     */
-    merge(otherTransaction: Transaction): this;
-
-    // Execution methods
-    /**
-     * Set a callback to be executed after all the operations
-     * in the transaction were executed successfully
-     *
-     * @param callback the callback to be executed
-     * @return this transaction
-     */
-    afterExecution(callback: (success: boolean, message?: string) => void): this;
-
-    /**
-     * Execute atomically the transaction at the data sources. Return the transaction result if succeeds.
-     *
-     * @return promise resolving with the corresponding TransactionResult if the transaction succeeds,
-     * rejecting if the transaction fails
-     */
-    execute(): Promise<TransactionResult>;
-
-    /**
-     * Execute atomically a transaction at the data source and returns the transaction result if succeeds.
-     * The `large` mode sends the transaction over HTTP, this has the following incidence:
-     * - Quicker processing of transaction
-     * - Allows transactions with no limit of size
-     * - Cannot be used when logged as Guest
-     *
-     * @return promise resolving with the corresponding TransactionResult if the transaction succeeds,
-     * rejecting if the transaction fails.
-     */
-    executeAsLarge(): Promise<TransactionResult>;
-
-    /**
-     * Start a transaction using an existing transaction in the provided context
-     * or a new one if there is none.
-     *
-     * @param $ context in which the transaction executes
-     * @return transaction
-     */
-    static from($: BrickContext): Transaction;
-
-    /**
-     * Execute a given transaction if there is no open transaction in the context.
-     *
-     * @param $ context
-     * @param transaction transaction to process
-     * @return boolean indicating if the argument transaction has been processed
-     */
-    static process($: BrickContext, transaction: Transaction): Promise<boolean>;
-}
-
-/**
- * Predefined data sources that can be used for {@apilink Transaction.setSource}.
- */
-export enum PredefinedDataSource {
-    /**
-     * Local DataSource. By using this source, objects are not persisted
-     */
-    SELF = 'self',
-    /**
-     * Embedded Graph Database
-     */
-    SERVER = 'server'
-}
-
-/**
- * When manipulating CloudObjects, sometimes it is required to manually set the data source of that object.
- * `Source` determines where the object comes from: what data source is the owner of the object across the ecosystem.
- */
-
-export type Source = PredefinedDataSource | string;
-
-/**
- * A transaction result is the object received after a transaction has been executed successfully.
- * It provides information about what has been done.
- */
-export class TransactionResult {
-
-    /**
-     * Return the ordered list of CloudObjects created in this transaction.
-     *
-     * @return the list of CloudObjects instances
-     */
-    getCreatedObjects(): CloudObject[];
-}
-
-/**
- * BurstTransactions are designed to continuously apply high rates of updates on properties (FIFO ordering).
- * The only operation supported by BurstTransactions is to update properties of an instance.
- *
- * Unlike classical Transactions, a burst transaction preserves the order of update operations and
- * is designed to handle many updates per second for smooth shared animations.
- *
- * Example of use:
- * A marker representing a red dot on the screen which coordinate properties are controlled by motion sensors of an IoT device
- * should use BurstTransaction instead of a bunch of continuous classical Transaction to have fluid movements on the screen.
- */
-export class BurstTransaction {
-    constructor();
-
-    /**
-     * Push all property values from specified Observable to update specified object
-     *
-     * @param object the object to update
-     * @param values observable mapping properties to new values
-     */
-    push<T>(object: CloudObject, values: Observable<Map<Property<T>, T>>): void;
-
-    /**
-     * Commit and close the burst transaction
-     *
-     * @return A `Promise` completing with commit success/failure
-     */
-    complete(): Promise<void>;
-}
-
-// ----------------------
-// -- Database queries --
-// ----------------------
-
-/**
- * A QueryResult is a list of key-value pairs that has been generated as a result of a `Query`.
- * It contains the result of a query at a specific time.
- *
- * The keys are tags (e.g. `myTag`) that correspond to a `CloudObject` (e.g. `myCloudObject`).
- * When the {@apilink Query} contains more than one {@apilink Query.andReturn Query.andReturn()} clause,
- * keys are composite tags (e.g. `'tag1.tag2.tag3'`) and values are tuples of `CloudObjects` (e.g. `[cloudObj1, cloudObj2, cloudObj3]`).
- * Such a QueryResult can be obtained via:
- * ```javascript
- * Query.instancesOf(myModel1).andReturn.follow(myRelation1).andReturn.follow(myRelation2).andReturn().execute().
- * ```
- *
- * When a query is subscribed, the returned observable generates multiple QueryResults over time.
- *
- * A QueryResult can be easily manipulated and transformed to a standard Array.
- */
-export class QueryResult<T extends CloudObject | CloudObject[]> {
-    /**
-     *@return empty `QueryResult`
-     */
-    static empty(): QueryResult<any>;
-
-    /**
-     * Symbol iterator for `for…in` syntactic sugar
-     *
-     * @return iterator over the key-values pairs of this `QueryResult`
-     */
-    [Symbol.iterator](): IterableIterator<[string, T]>;
-
-    /**
-     * Get an iterable iterator over the key-value pairs of this `QueryResult`
-     *
-     * @return iterator
-     */
-    entries(): IterableIterator<[string, T]>;
-
-    /**
-     * Get an iterable iterator over the values of this `QueryResult`
-     *
-     * @return iterator
-     */
-    values(): IterableIterator<T>
-
-    /**
-     * Get an iterable iterator over the keys of this `QueryResult`
-     *
-     * @return iterator
-     */
-    keys(): IterableIterator<string>
-
-    /**
-     * Get an array containing the values of this `QueryResult`
-     *
-     * @return array of this `QueryResult`'s values
-     */
-    toArray(): T[];
-
-    /**
-     * Get the number of key-value pairs this `QueryResult` contains
-     *
-     * @return size of this `QueryResult`
-     */
-    size(): number;
-
-    /**
-     * Check whether a key / value is contained in this `QueryResult`.
-     *
-     * Returns true if the cloud array contains an element with the specified key.
-     *
-     * If no corresponding key is found, returns true if the cloud array contains an element with the specified value.
-     *
-     * @param key the value to search for
-     * @return true if the value `key` is found
-     */
-    has(key: T | string): boolean;
-
-    /**
-     * Get index of a value in the keys or values of this `QueryResult`.
-     *
-     * If the key is a string, retrieve the index from the `string` keys of this `QueryResult`.
-     *
-     * If the key is not a string, get the index from the `CloudObject` tuples
-     *
-     * @param key the value to find the index of
-     * @return index of the argument value or -1 if the value is not found
-     */
-    indexOf(key: T | string): number;
-
-    /**
-     * Get the value corresponding to a given key
-     *
-     * @param key tag or composite tag
-     * @return matching tuple or `null`
-     */
-    get(key: string): T | null;
-
-    /**
-     * Get the first value
-     *
-     * @return first value or `null` if empty
-     */
-    getFirst(): T | null;
-
-    /**
-     * Get the value at the specified index
-     *
-     * @param index
-     * @return value at position `index` or `null` if index is out of bounds
-     */
-    getAt(index: number): T | null;
-
-    /**
-     * Query Results, when used in a subscription, can be used to observe changes compare to the previous QueryResult.
-     * This method returns the values that have added from the previous QueryResult.
-     *
-     * @return array of added values (CloudObjects or tuples of CloudObjects)
-     */
-    getAdded(): T[];
-
-    /**
-     * Query Results, when used in a subscription, can be used to observe changes compare to the previous QueryResult.
-     * This method returns the values the keys (eg: tags) of values that have been removed from the previous QueryResult.
-     *
-     * @return array of removed keys (tags or tags concatenation (tuples))
-     */
-    getRemoved(): string[];
-
-    /**
-     * Returns an array equivalent to {@apilink QueryResult.toArray | this.toArray().push(...object)}
-     *
-     * This operation returns a new array and does not modify this QueryResult.
-     *
-     * @param object new values to push in the values array.
-     * @return new values array with new elements appended
-     */
-    push(...object: T[]): T[];
-
-    /**
-     * Returns the QueryResult values as an array whose last value has been removed.
-     *
-     * If {@apilink QueryResult.size} is 0 or 1, this method returns an empty array.
-     *
-     * This operation returns a new array and does not modify this QueryResult.
-     *
-     * @return new values array with last element removed
-     */
-    pop(): T[];
-
-    /**
-     * Returns the QueryResult values as an array whose first value has been removed.
-     *
-     * If {@apilink QueryResult.size} is 0 or 1, this method returns an empty array.
-     *
-     * This operation returns a new array and does not modify this QueryResult.
-     *
-     * @return new values array with first element removed
-     */
-    shift(): T[];
-
-    /**
-     * Returns an array containing the values matching the provided filter predicate.
-     *
-     * @param predicate filter {@apilink Predicate}
-     * @return array of matching values
-     */
-    filter(predicate: (entry: T, index: number) => boolean): T[];
-
-    /**
-     * Returns the first value matching the predicate, `null` otherwise.
-     *
-     * `find` calls `predicate` once for each element of the array until it returns true.
-     * If such an element is found, find immediately returns that element value.
-     *
-     * @param predicate
-     * @return the first value evaluating to true or `null`
-     */
-    find(predicate: (entry: T, index: number) => boolean): T | null;
-
-    /**
-     * Execute the specified callback function for each value of this `QueryResult`
-     *
-     * @param callback
-     */
-    forEach(callback: (entry: T, index: number) => void): void;
-
-    /**
-     * Execute the specified callback function for each value of this `QueryResult`.
-     * It returns a new array that contains the results of the callback execution.
-     *
-     * @param callback
-     * @return new array of transformed values
-     */
-    map<S>(callback: (entry: T, index: number) => S): S[];
-
-    /**
-     * Return a sorted copy of this QueryResult.
-     *
-     * The specified `comparator` used to determine the order of the QueryResult key-value pairs.
-     * It compares two QueryResult values and should return a negative number if the first value shall be present before the second, zero if they're at the same position, and a positive
-     * number otherwise.
-     *
-     * @param comparator comparator returning a negative, zero or positive number
-     * @return sorted copy of this QueryResult
-     */
-    sort(comparator: (b1: T, b2: T) => number): QueryResult<T>;
-
-    /**
-     * Return a reduced value for this QueryResult.
-     *
-     * The specified `reducer` callback reduces the QueryResult values. Similar to `Array.reduce()`.
-     *
-     * @param reducer callback
-     * @param initial initial value of the accumulator
-     * @return  accumulated result applying the `reducer` function iteratively
-     */
-    reduce<S>(reducer: (accumulator: S, entry: T, index: number) => S, initial: S): S;
-
-    /**
-     * Return a new QueryResult that contains the concatenation of two or more QueryResults.
-     *
-     * Concatenating two QueryResults results in a new QueryResult with the following:
-     *
-     * - the keys of the QueryResults are concatenated
-     * - the values of the QueryResults are concatenated
-     * - the arrays returned by {@apilink QueryResult.getAdded} are concatenated
-     * - the arrays returned by {@apilink QueryResult.getRemoved} are concatenated
-     *
-     * Example : ```javascript
-     * const result1 = Query.fromInstances(myModel1).executeFromCache();
-     * // result1 is {tag1: cloudObj1, tag2: cloudObj2}
-     * const result2 = Query.fromInstances(myModel2).executeFromCache();
-     * // result2 is {tag3: cloudObj3}
-     * const concatenatedResult = result2.concat(result1);
-     * // concatenatedResult is {tag3: cloudObj3, tag1: cloudObj1, tag2: cloudObj2}
-     * ```
-     *
-     * @param others QueryResults to append to this `QueryResult`
-     * @return concatenated query results
-     */
-    concat(...others: QueryResult<T>[]): QueryResult<T>;
-}
-
-declare type QueryOptions = {
-    cacheBucketName?: string; // Name of the cache bucket - if provided, it means that the query must be cached under this name
-}
-
-declare type ImplicitQueryOption = {
-    storeInCacheDB?: boolean // indicates if this follow rule query must be cached in browser DB (IndexedDB) for potential offline use. Default is false.
-}
-
-/**
- * A Query is an immutable object used to build queries on the datacloud. It is a graph query builder.
- * It starts from an `origin` InstanceOrTag (typically, the `InstanceOrTag` of a data type or of an instance).
- * From there, it can follow relations between data types and filter results.
- *
- * Example:
- *
- *  `origin --a--> X --b--> Y --c--> Z`
- *
- * Example:
- *
- * ```javascript
- *  Query.from(origin)
- *      .follow(a)
- *      .execute();
- * ```
- *  This will return a Promise of a QueryResult whose values are of type X: `Promise<QueryResult<X>>`.
- *
- * A query defines a starting working set of nodes and operations that will mutate it.
- * From our example,the working set is first the `origin` graph node. Then the `follow`
- * operations create a new working set only containing the nodes related to the origin through relation *`a`*.
- *
- * Multiple relations can be followed at once to create the equivalent of JOIN operations in relational databases.
- * ```javascript
- *  Query.from(origin)
- *      .follow(a).andReturn()
- *      .follow(b)
- *      .follow(c).andReturn()
- *      .execute();
- * ```
- * The next operation defines a working set containing the nodes related
- * through relation *`b`* to nodes that are related through relation *`a`* to the origin.
- * A similar operation is defined for relation `c`.
- * At each level, "andReturn()" method can be called to add the current level to the result.
- * This will return a Promise of a QueryResult whose values are of type [X, Z]: `Promise<QueryResult<[X, Z]>>`.
- *
- * Out of the 4 working sets created, only the second and fourth are flagged to be returned and part of the result.
- * But the operations in the middle impact this result: e.g.,
- * all returned tuples (t1, t2) are object that have an intermediate `i` of type Y.
- * such that `t1 --b-> i --c-> t2` but the `i` was not flagged to be returned.
- *
- * Queries define a path from a starting point following a specific list of relations.
- * As explained with our example, only nodes part of a full path can be returned.
- *
- *
- * A query can be executed with 3 different ways:
- * - execute(): it runs the query on the datacloud and return the result as a QueryResult.
- * - observe(): it runs the query on the datacloud and subscribes to updates. It returns an Observable which provides a new QueryResult every time the result changes.
- * - executeFromCache(): it runs the query on the *local* datacloud which may be incomplete view of the datacloud (it is the local cache). It is executed synchronously.
- */
-export class Query<T extends CloudObject, R> {
-
-    /**
-     * Create a query starting from the `CloudObject` specified tag.
-     * That `CloudObject` must already exist in the local database. In case you have the tag as a `string` and need to get
-     * the object from a remote database, use {@apilink Query.fromTag} instead.
-     *
-     * @param tag tag of the `CloudObject` the query is starting from
-     * @param source optional source of the data to answer the query
-     * @return an empty Query whose starting point is defined by a single `CloudObject`
-     */
-    static from<T extends InstanceOrTag>(tag: T, source?: Source): Query<T extends CloudObject ? T : CloudObject, never>;
-
-    /**
-     * Create a query starting from the `CloudObject` specified tag.
-     * The difference with {@apilink Query.from} method is that you specify the data type of the Tag: this allows to execute
-     * queries with a tag that is unknown by the local database, on the right remote database.
-     *
-     * @param tag tag of the `CloudObject` the query is starting from
-     * @param dataType data type of the `tag` `CloudObject`.
-     * @param source optional source of the data to answer the query
-     * @return an empty Query whose starting point is defined by a single `CloudObject`
-     */
-    static fromTag<T extends CloudObject>(tag: string, dataType: Class<T> | InstanceOrTag, source?: Source): Query<T, never>;
-
-    /**
-     * Create a query starting from the instances of the specified model. By default, it does include the instances of
-     * the models that inherit from the given one.
-     *
-     * @param model tag/class of the model to find the instances of
-     * @param includeInheritance if set to false, the result will not include instances of models that inherit from the given model.
-     * @param source optional source of the data to answer the query
-     * A source can be the orchestrator ('server'), local ('self') or
-     * an external data source (Tag of a `DBConnectorTag`)
-     * @return a new query object starting from model instances
-     */
-    static instancesOf<T extends InstanceOrTag>(model: Class<T> | InstanceOrTag, includeInheritance?: boolean, source?: Source): Query<T extends CloudObject ? T : CloudObject, never>;
-
-    /**
-     * Create a query starting from a specific root instance, then following relations based on a rule constraint.
-     * @param ctx Context in which the {@apilink Query} is observed
-     * @param root Starting point of the query. See `root` of {@apilink RootQueryPart}
-     * @param rule Discriminate which relations to follow
-     * @param source The tag of the source responsible for executing the query
-     * @param options options
-     */
-    static followRule<T extends InstanceOrTag>(ctx: Context, root: T, rule: FollowRule, source?: Source, options?: ImplicitQueryOption): Observable<QueryResult<T extends CloudObject ? T : CloudObject>>;
-
-    /**
-     * Instruct the query to follow a specified relation. This does not add any key-value pair to the result.
-     * (see {@apilink Query.andReturn}). This operation defines a new step in the path defined by our graph query.
-     *
-     * Example:
-     * Find the model of a single object.
-     * ```javascript
-     * Query.from(myTag).follow(CloudObject.modelRel).andReturn()
-     * ```
-     *
-     * @param relation relation to follow, specifies type and direction
-     * @param optional whether or not the relation creates a mandatory path in the graph to be part of the result.
-     * @return a new query object
-     */
-    follow<D extends CloudObject>(relation: Relation<T, D>, optional?: boolean): Query<D, R>;
-
-    /**
-     * Follow a relation recursively, see {@apilink Query.follow}.
-     * The relation that is followed is automatically recursively followed.
-     * All nodes that are recursively followed are part of the same step in the path defined by this graph query.
-     *
-     * @param relation relation to follow recursively, specifies type and direction.
-     * @param includeSelf if a starting node includes itself when the relation loops on itself. (default: false)
-     * @param optional whether or not the relation creates a mandatory path in the graph to be part of the result. (default: false)
-     * @return a new query object
-     */
-    followRecursively<D extends CloudObject>(relation: Relation<T, D>, includeSelf?: boolean, optional?: boolean): Query<D, R>;
-
-    /**
-     * The Query.back() function is used to move the cursor of a query backwards to the previous level.
-     * This allows the query to start from the place where it was before a Query.follow() call,
-     * but with a different relation. The `times` parameter is optional and specifies the number of steps to go back.
-     * If hops is not specified, the default value of 1 is used.
-     * If a value <= 0 is specified, the output query is the same as the input query.
-     *
-     * Example:
-     * const people = [
-     *   \{ name: "Alice", children: ["Bob", "Carol"], siblings: ["David"] \},
-     *   \{ name: "Bob", children: ["Emily"], siblings: ["Alice", "Carol", "David"] \},
-     *   \{ name: "Carol", children: ["Frank"], siblings: ["Alice", "Bob", "David"] \},
-     *   \{ name: "David", children: ["Greg"], siblings: ["Alice", "Bob", "Carol"] \},
-     *   \{ name: "Emily", children: [], siblings: [] \},
-     *   \{ name: "Frank", children: [], siblings: [] \},
-     *   \{ name: "Greg", children: [], siblings: [] \}
-     * ];
-     *
-     * // Create a new query starting from Alice
-     * const aliceQuery = Query.from("Alice");
-     *
-     * // Follow the "children" relation to get Alice's children (Bob, Carol)
-     * const aliceChildrenQuery = aliceQuery.follow("children").andReturn();
-     *
-     * // Go back to the previous level and follow the "siblings" relation to get Alice's siblings (David)
-     * const aliceSiblingsQuery = aliceChildrenQuery.back().follow("siblings").andReturn();
-     *
-     * // Execute the query, the output is:
-     * Output: [ \{ sibling: 'David', child: 'Bob' \}, \{ sibling: 'David', child: 'Carol' \} ]
-     * @param times
-     * @return {!Query}
-     */
-    back(times?: number): Query<CloudObject, R>;
-
-    /**
-     * Add the current working set of nodes to the result.
-     *
-     * Example:
-     * Query returning the instances of a model and the model itself
-     * ```javascript
-     * Query
-     *      .from(myModelTag).andReturn()
-     *      .follow(CloudObject.modelRel.getInverse()).andReturn()
-     *      .execute();
-     * ```
-     * The result tuples are [modelCloudObject, instance1], [modelCloudObject, instance2], ...
-     *
-     * @return a new query object with the current level flagged to be returned.
-     */
-    andReturn(): Query<T, R extends never ? T : R extends CloudObject[] ? [...R, T] : [R, T]>;
-
-    /**
-     * Define a filter operation on the current working set of nodes.
-     * It filters out instances that don't match the given {@apilink Predicate}
-     *
-     * @param predicate
-     * @return a new query object with the new filter operation
-     */
-    filter(predicate: Predicate): Query<T, R>;
-
-    /**
-     * Cast the type of the instances in the current working set of nodes
-     *
-     * @param type cast type for `CloudObjects`
-     * @return the
-     */
-    cast<S extends CloudObject>(type: Class<S>): Query<S, R>;
-
-    /**
-     * Set the maximum number of tuples the executed query will return with an optional offset.
-     *
-     * Only the last call to limit matters.
-     *
-     * Example :
-     * ```javascript
-     * const queryLimited = query.limit(50).follow(myRel2).limit(100, 200).follow(myRel1);
-     * // is equivalent to
-     * const queryLimited2 = query.follow(myRel2).follow(myRel1).limit(100, 200);
-     * ```
-     * `queryLimited`, when executed, will return at most the 200th to the 299th (included) results.
-     *
-     * @param max maximum number of tuple to fetch from the final result
-     * @param offset number of skipped tuples for the final result
-     * @return new query with limit operation
-     */
-    limit(max: number, offset?: number): Query<T, R>;
-
-    /**
-     * Sort the result tuples according to a property of a data type with a specified order.
-     **
-     * For the sortBy operator to be properly defined, the following must be true:
-     * - the property is defined on the instances that will be used for sorting.
-     * - the instances on which the sorting property is defined must be part of the result,
-     * i.e., `andReturn()` has been called before `sortBy()`.
-     *
-     * Only the last call to `sortBy` matters as it will be the last comparator set on the query.
-     * You should remove previous calls to `sortBy` for the same query.
-     *
-     * Example :
-     * ```javascript
-     * const sortQuery = Query
-     *      .fromInstances(myModel1).andReturn()
-     *      .sortBy(nameProperty)
-     *      .follow(rel1).andReturn()
-     *      .execute();
-     * ```
-     * This query fetches instances of a model, flags them as first element of result tuples.
-     * Then the query follows a relation to other instances and return them as second element of the result tuples.
-     * `sortBy` will sort the results according to the `nameProperty` of the first element in the result tuples in
-     * ascending order.
-     *
-     * @param property the property used for sorting
-     * @param order optional {@apilink Order.ASC} (default) or {@apilink Order.DESC} order
-     * @return new query with sort operation
-     */
-    sortBy(property: Property<any>, order?: Order): Query<T, R>;
-
-    /**
-     * @return the query transformed as a tree of QueryPart. To be used by Data Source.
-     */
-    parse(): RootQueryPart;
-
-    /**
-     * Execute the query asynchronously on the datacloud and deletes it afterward.
-     * In other words, one cannot call execute twice on the same `Query`.
-     *
-     * @param options options
-     * @return promise resolving to query result or failing otherwise.
-     */
-    execute(options?: QueryOptions): Promise<QueryResult<R extends never ? T : R extends CloudObject | CloudObject[] ? R : never>>;
-
-    /**
-     * Get an observable to the current value of the QueryResult for this Query instance.
-     *
-     * The observable gets the new value each time data modification in the datacloud changes the result of the query.
-     *
-     * The observable gets completed automatically once the specified context is {@apilink Context.onClear | cleared}.
-     *
-     * @param context {@apilink Context} to which the Observable is attached
-     * @param options options
-     * @return Observable of QueryResult values
-     */
-    observe(context: Context, options?: QueryOptions): Observable<QueryResult<R extends never ? T : R extends CloudObject | CloudObject[] ? R : never>>;
-
-    /**
-     * Execute synchronously the query on the local datacloud cache.
-     * `executeFromCache` can only be called once on a given `Query`.
-     *
-     * @return query result of the execution on the local cache
-     */
-    executeFromCache(): QueryResult<R extends never ? T : R extends CloudObject | CloudObject[] ? R : never>;
-}
-
-/**
- * A QuerySingle is a Query which follows relations that should be unique between data types (0..1 and 1..1 cardinalities).
- * It returns the instance related to the origin, following the specified relation(s).
- *
- * It acts as a syntactic sugar to avoid having a query result structure and get the first value out of it.
- *
- * A QuerySingle is immutable.
- */
-export class QuerySingle<T extends CloudObject> {
-    /**
-     * Create a `query single` from a single node.
-     * See {@apilink Query.from}
-     *
-     * @param object starting node for the graph query single
-     * @return new query single only accepting 0..1 relations
-     */
-    static from<T extends CloudObject>(object: InstanceOrTag): QuerySingle<T>;
-
-    /**
-     * Follow a 0..1 relation
-     * See {@apilink Query.follow | Query.follow()}
-     *
-     * @param relation relation to next node
-     * @return new query single with follow operation
-     */
-    follow<D extends CloudObject>(relation: Relation<T, D>): QuerySingle<D>;
-
-    /**
-     * See {@apilink Query.cast | Query.cast()}
-     *
-     * @param type the new type
-     * @return query single on a node of the specified type
-     */
-    cast<S extends CloudObject>(type: Class<S>): QuerySingle<S>;
-
-    /**
-     * Execute the query single, see {@apilink Query.execute | Query.execute()}
-     *
-     * @return promise containing the single result or `null`
-     */
-    execute(): Promise<T | null>;
-
-    /**
-     * Execute the query single on the local data cloud,
-     * see {@apilink Query.executeFromCache | Query.executeFromCache()}
-     *
-     * @return single result value or `null`
-     */
-    executeFromCache(): T | null;
-}
-
-/**
- * Predicates are used to filter queries.
- *
- * Example:
- * ```javascript
- * const predicate = Predicate.equals(myNumberProperty, 1);
- * const filteredQuery = Query.instancesOf(myModel).filter(predicate).andReturn();
- * ```
- */
-export class Predicate {
-
-    /**
-     * Create a predicate to match the specified object(s).
-     *
-     * @param tags the object or unique identifier (tag) of the objects to look for.
-     */
-    static in(...tags: InstanceOrTag[]): Predicate;
-
-    /**
-     * Create a predicate matching a specified property to a specified value.
-     *
-     * @param property the property to use for filtering
-     * @param value the value the property must match
-     * @return new Predicate with the equals operation
-     */
-    static equals<T>(property: Property<T>, value: T): Predicate;
-
-    /**
-     * Create a predicate matching a specified string property to a specified string.
-     *
-     * @param property the string property to use for filtering
-     * @param value the value the string property must match
-     * @param caseSensitive if the match must pay attention to case sensitivity, default value is true
-     * @return new Predicate with the contains string operation
-     */
-    static contains(property: Property<string>, value: string, caseSensitive?: boolean): Predicate;
-
-    /**
-     * Create a predicate matching a specified string property to a regular expression.
-     *
-     * @param property the string property to use for filtering
-     * @param value the regex or pattern the string property must match
-     * @param caseSensitive if the match must pay attention to case sensitivity, default value is true
-     * @return new Predicate with the match regex operation
-     */
-    static regex(property: Property<string>, value: RegExp | string, caseSensitive?: boolean): Predicate;
-
-    /**
-     * Create a predicate matching a specified number property to a numerical lower bound
-     *
-     * @param property the number property to user for filtering
-     * @param value the lower bound
-     * @param strict if the inequality is strict or not
-     * @return new Predicate with the greaterThan mathematical operation
-     */
-    static greaterThan(property: Property<number>, value: number, strict?: boolean): Predicate;
-
-    /**
-     * Create a predicate matching a specified number property to a numerical upper bound
-     *
-     * @param property the number property to user for filtering
-     * @param value the upper bound
-     * @param strict if the inequality is strict or not
-     * @return new Predicate with the smallerThan mathematical operation
-     */
-    static smallerThan(property: Property<number>, value: number, strict?: boolean): Predicate;
-
-    /**
-     * Create a predicate matching a specified number property to a number property lower bound
-     *
-     * @param property1 the number property to user for filtering
-     * @param property2 the lower bound number property
-     * @param strict if the inequality is strict or not
-     * @return new Predicate with the greaterThan mathematical operation
-     */
-    static greaterThan(property1: Property<number>, property2: Property<number>, strict?: boolean): Predicate;
-
-    /**
-     * Create a predicate matching a specified number property to a number property upper bound
-     *
-     * @param property1 the number property to user for filtering
-     * @param property2 the upper bound number property
-     * @param strict if the inequality is strict or not
-     * @return new Predicate with the smallerThan mathematical operation
-     */
-    static smallerThan(property1: Property<number>, property2: Property<number>, strict?: boolean): Predicate;
-
-    /**
-     * Create an AND composite predicate matching a specified set of predicates
-     *
-     * @param predicates list of predicates to match
-     * @return new Predicate that should match all specified predicates
-     */
-    static and(...predicates: Predicate[]): Predicate;
-
-    /**
-     * Create an OR composite predicate matching a specified set of predicates
-     *
-     * @param predicates list of predicates to match
-     * @return new Predicate that should match at least one specified predicate
-     */
-    static or(...predicates: Predicate[]): Predicate;
-
-    /**
-     * Create a NOT  predicate matching the opposite of a specified predicate
-     *
-     * @param predicate the predicate to inverse
-     * @return new Predicate that match when the specified predicate does not
-     */
-    static not(predicate: Predicate): Predicate;
-}
-
-/**
- * The sorting order for a {@apilink QueryPart}.
- */
-export enum Order {
-    /**
-     * Ascending order.
-     */
-    ASC,
-    /**
-     * Descending order.
-     */
-    DESC
-}
-
-/**
- * A class representing the necessary operations to create the result of a query in the client database
- * that emitted the query.
- */
-export class DataResult {
-
-    /**
-     * Create a new {@apilink DataResult} instance from the specified {@apilink Query}.
-     * @param query The {@apilink Query} to create a {@apilink DataResult} from.
-     * @return A new {@apilink DataResult} instance.
-     */
-    static fromQuery(query: Query<CloudObject, any>): DataResult;
-
-    /**
-     * Create a new Data Type instance with the specified {@apilink InstanceOrTag}, Data Type and properties.
-     * @param tag The unique identifier of the object instance to create.
-     * @param model The Data Type of the instance to create.
-     * @param properties The properties to set on the instance.
-     * @return This {@apilink DataResult} instance.
-     */
-    create(tag: InstanceOrTag, model: InstanceOrTag, properties?: Map<InstanceOrTag, any>): this;
-
-    /**
-     * Create a relation between two instances with the specified {@apilink Relation}, `from`, and `to` instance tags.
-     * @param relation The type of relation to create.
-     * @param from The unique identifier of the source instance.
-     * @param to The unique identifier of the destination instance.
-     * @return This {@apilink DataResult} instance.
-     */
-    createRelation(relation: InstanceOrTag, from: InstanceOrTag, to: InstanceOrTag): this;
-}
-
-/**
- * Represents an operation that can be performed regarding data type instances.
- */
-export type Operation =
-    {
-        /** Creates a new instance of a data type with the given properties. */
-        type: 'CREATE',
-        /** The tag of the new instance. */
-        object: string,
-        /** The data type tag of the instance being created. */
-        model: string,
-        /** A map that maps the tag of a property to a new/updated value.
-         *  You may need to parse this value to store it in your data source (e.g. JS date)
-         * */
-        properties?: Map<string, any>
-    } |
-    {
-        /** Updates an existing instance of a data type with the given properties. */
-        type: 'UPDATE',
-        /** The tag of the instance being updated. */
-        object: string,
-        /** The data type tag of the instance being updated. */
-        model: string,
-        /** A map that maps the tag of a property to a new/updated value.
-         *  You may need to parse this value to store it in your data source (e.g. JS date)
-         * */
-        properties: Map<string, any>
-    } |
-    {
-        /** Deletes an existing instance of a data type. */
-        type: 'DELETE',
-        /** The tag of the instance being deleted. */
-        object: string,
-        /** The data type tag of the instance being deleted. */
-        model: string
-    } |
-    {
-        /** Creates a new relation between two instances of a data type. */
-        type: 'CREATE_RELATION',
-        /** The tag of the relation being created. */
-        relation: string,
-        /** The tag of the starting instance. */
-        from: string,
-        /** The tag of the ending instance. */
-        to: string,
-        /** The data type tag of the starting instance. */
-        fromModel: string,
-        /** The data type tag of the ending instance. */
-        toModel: string
-    } |
-    {
-        /** Deletes an existing relation between two instances of a data type. */
-        type: 'DELETE_RELATION',
-        /** The tag of the relation being deleted. */
-        relation: string,
-        /** The tag of the starting instance. */
-        from: string,
-        /** The tag of the ending instance. */
-        to: string,
-        /** The data type tag of the starting instance. */
-        fromModel: string,
-        /** The data type tag of the ending instance. */
-        toModel: string
-    };
-/**
- * Details for a predicate from the OLYMPE query API
- */
-export type ParsedPredicate =
-    {
-        /** Checks if the instance has any of the specified tags. */
-        name: 'IS',
-        /** An array of tags to check against. */
-        tags: string[]
-    } |
-    {
-        /** Checks if a string type property contains a specific string value. */
-        name: 'CONTAINS',
-        /** The tag of the property being checked. */
-        property: string,
-        /** The value being searched for. */
-        value: string,
-        /** Whether the search should be case-sensitive or not. */
-        caseSensitive: boolean
-    } |
-    {
-        /** Checks if a property equals a specific value. */
-        name: 'EQUALS',
-        /** The tag of the property being checked. */
-        property: string,
-        /** The value being compared to. */
-        value: any
-    } |
-    {
-        /** Checks if a property is greater than or less than a specific value. */
-        name: 'INEQUALITY_OPERATOR',
-        /** The tag of the property being compared. */
-        property: string,
-        /** The value being compared to. */
-        value: any,
-        /** The operator being used in the comparison (e.g. "<", ">"). */
-        operator: string,
-        /** Whether the comparison should be strict (e.g. "<" vs. "<="). */
-        strict: boolean
-    } |
-    {
-        /** Negates a predicate. */
-        name: 'NOT',
-        /** The predicate being negated. */
-        predicate: ParsedPredicate
-    } |
-    {
-        /** Checks if a property matches a regular expression pattern. */
-        name: 'REGEX',
-        /** The tag of the property being checked. */
-        property: string,
-        /** The regular expression pattern being matched. */
-        pattern: RegExp,
-        /** Whether the matching should be case-sensitive or not. */
-        caseSensitive: boolean
-    };
-
-/**
- * The first part of a {@apilink Query}.
- * It breaks down the starting point of the query.
- */
-export interface RootQueryPart extends QueryPart {
-    /**
-     * The tag of the starting point of a query built using {@apilink Query.from()}
-     * It is the tag of the instance where the first relation followed using {@apilink Query.follow()} starts from.
-     * For queries on instances of a data type, started with  {@apilink Query.instancesOf()}, this will be null.
-     */
-    root?: string
-    /**
-     * The tag of the Data Type of the instance(s) determining the starting point of the query.
-     * It is the tag of the Data Type provided to {@apilink Query.instancesOf()}, or the Data Type of the root instance provided
-     * to {@apilink Query.from()}
-     */
-    dataType: string
-    /**
-     * Specifies whether instances of the data types inheriting from the root data type should be included in the query or not.
-     * It is always `false` if `root` is specified.
-     */
-    inheritance: boolean
-    /**
-     * Limits the number of results retrieved by the query.
-     */
-    limit: number
-    /**
-     * Skips a specified number of results retrieved by the query.
-     */
-    offset: number
-}
-
-/**
- * A part of a {@apilink Query} that specifies a relationship to traverse.
- */
-export interface QueryPart {
-    /**
-     * Determines whether the relationship should be traversed recursively and whether the starting object should be included.
-     * `false`: Traverse the relationship once.
-     * `'EXCLUDE_SELF'`: Traverse the relationship recursively, excluding the starting object.
-     * `'INCLUDE_SELF'`: Traverse the relationship recursively, including the starting object.
-     */
-    recursive: false | 'EXCLUDE_SELF' | 'INCLUDE_SELF',
-    /**
-     * Specifies a relationship to traverse in the query.
-     */
-    relation: Relation<any, any>
-    /**
-     * Determines whether the relationship this part specifies is optional or not to traverse.
-     * If `true`, result tuples may have a null if this relationship can not be followed from some data objects.
-     * If `false`, all result tuples must contain this relationship.
-     */
-    optional: boolean,
-    /**
-     * Determines whether the related objects should be included in the result tuples.
-     * If `true`, related objects will be included.
-     * If `false`, the related objects are not included.
-     * This does not impact whether the relationship is `optional` to be traversed.
-     */
-    returned: boolean,
-    /**
-     * Specify if the instances obtained by following the relation should satisfy some condition
-     * See {@apilink ParsedPredicate}
-     */
-    filter: ParsedPredicate[][],
-    /**
-     * Set a sorting order on the result tuples according to the related objects.
-     * It will sort using native order of the type of the property.
-     * For multiple parts with sort information, the latest part will prevail.
-     */
-    sort?: {property: Property<any>, order: Order}
-    /**
-     * Returns the remaining {@apilink QueryPart}s of the query, empty if no {@apilink QueryPart}s are left.
-     */
-    next: QueryPart[]
-}
-/**
- * Represents a data source that can be used to retrieve, manipulate and store data outside the Olympe application environment.
- * This class provides several methods for performing CRUD (create, read, update, delete) operations on data,
- * as well as file upload and download functionality.
- *
- * To create a new data source, add a _Data Connector_ in your project in DRAW and download the boilerplate.
- * Then implement or extend the required methods: `init`, `destroy`, `healthCheck`, `executeQuery` and `applyTransaction`
- * For file capabilities, you must also implement: `uploadFileContent`, `downloadFileContent` and `deleteFileContent`
- *
- * The CORE library already provide some default connectors such as PostgreSQL and MSSQL.
- * Their implementation is open source and available in [CORE on Github](https://github.com/olympeio/CORE/tree/master/src/core/data/connectors).
- *
- * @abstract
- * @extends {@apilink CloudObject}
- */
-export abstract class DataSource extends CloudObject {
-
-    /**
-     * Returns the tag of the data source.
-     * @return tag of the data source.
-     */
-    getId(): string;
-
-    /**
-     * Retrieves the configuration value associated with the provided key in the data source oConfig.
-     * @param key - Key to retrieve the configuration value for.
-     * @return The configuration value associated with the provided key.
-     */
-    getConfig(key: string): any;
-
-    /**
-     * Initializes the data source connection with custom parameters provided in oConfig.
-     * It can also perform a health check to ensure the connection is active.
-     * Subscribes to the {@apilink DataSource.observeDataTypes} observable to handle changes to the data types in the data source.
-     *
-     * @param context a context with the same livecycle as the Data Source
-     * @return A promise that resolves with void when initialization is complete. Reject if initialization did not complete.
-     */
-    protected init(context: BrickContext): Promise<void>;
-
-    /**
-     * Performs a health check on the data source, checking if the connection is alive.
-     * @return A Promise that resolves when the health check is completed successfully, rejects otherwise.
-     */
-    protected healthCheck(): Promise<void>;
-
-    /**
-     * Disconnects the data source.
-     * @return A Promise that resolves when the data source is destroyed.
-     */
-    protected destroy(): Promise<void>;
-
-    /**
-     * Executes the provided {@apilink Query} once and returns a {@apilink DataResult}.
-     * @param query - The {@apilink Query} object to execute.
-     * @return A Promise that resolves with the {@apilink DataResult} object.
-     */
-    protected executeQuery(query: Query<CloudObject, any>): Promise<DataResult>;
-
-    /**
-     * Applies the provided {@apilink Operation} array to the data source as one transaction
-     * @param transaction - The {@apilink Operation} array to apply.
-     * @param options the options
-     * @return A Promise that resolves when the transaction is completed. Rejects when the transaction fails.
-     */
-    protected applyTransaction(transaction: Operation[], options?: TransactionOptions): Promise<void>;
-
-    /**
-     * Uploads one file's content to the data source.
-     * @param fileTag - The tag of the file.
-     * @param dataType - The file data type
-     * @param binary - The binary data of the file.
-     * @return A Promise that resolves when the file content is uploaded. Rejects otherwise.
-     */
-    protected uploadFileContent(fileTag: string, dataType: string, binary: Uint8Array): Promise<void>;
-
-    /**
-     * Downloads one file's content from the data source.
-     * @param fileTag - The tag of the file.
-     * @param dataType - The file data type
-     * @return A Promise that resolves with the binary data of the file as an Uint8Array or a node Readable Stream. Rejects otherwise.
-     */
-    protected downloadFileContent(fileTag: string, dataType: string): Promise<Uint8Array | Readable>;
-
-    /**
-     * Deletes file content from the data source.
-     * @param fileTag - The tag of the file.
-     * @param dataType - The file data type
-     * @return A Promise that resolves when the file content is successfully deleted. Rejects otherwise.
-     */
-    protected deleteFileContent(fileTag: string, dataType: string): Promise<void>;
-}
-
-/**
- * Additional options for transactions to be processed by a data source.
- * - batch: if true, it means that the transaction has been executed using the {@apilink Transaction.executeAsLarge()} function.
- */
-export type TransactionOptions = {
-    batch: boolean
-};