@olympeio/runtime-node 9.3.0 → 9.4.0

package/types/cloud.d.ts

@@ -38,6 +38,8 @@ export class PropertyModel extends CloudObject {
     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.
@@ -56,15 +58,15 @@ export class RelationModel extends CloudObject {
     /**
      * Property for the *dump* follow rule
      */
-    static dumpFollowRuleProp: Property<number>;
+    static dumpFollowRuleProp: FollowRule;
     /**
      * Property for the *delete* follow rule
      */
-    static deleteFollowRuleProp: Property<number>;
+    static deleteFollowRuleProp: FollowRule;
     /**
      * Property for the *runtime* follow rule
      */
-    static runtimeFollowRuleProp: Property<number>;
+    static runtimeFollowRuleProp: FollowRule;
 }
 
 /**
@@ -103,41 +105,67 @@ export class ColorModel extends CloudObject {
 }
 
 /**
- * File with content as binary or string data
+ * 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: Tag, name: string, content: ArrayBuffer, mimeType?: string);
+
+    /**
+     * 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: Tag, name: string, url: string, mimeType?: string);
+
+    /**
+     * @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 ('server', 'self' or DBConnector tag)
+     * @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: ArrayBuffer, mimeType?: string, source?: string, tag?: string): string;
+    static createFromContent(transaction: Transaction, name: string, content: 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 ('server', 'self' or DBConnector tag)
+     * @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?: string, tag?: string): string;
+    static createFromURL(transaction: Transaction, name: string, url: string, mimeType?: string, source?: Source, tag?: string): string;
 
     /**
      * Retrieve content from this file asynchronously
@@ -336,7 +364,7 @@ export class Theme extends CloudObject {
  * 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.
+ * 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.
  *
@@ -372,7 +400,7 @@ export class Transaction {
      *
      * A custom map can specify property values for the instance.
      *
-     * A source can be the orchestrator ('server'), local ('self') or
+     * 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.
      *
@@ -382,7 +410,7 @@ export class Transaction {
      * @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: Tag, properties?: Map<Tag, any>, source?: string, tag?: string): string;
+    create(model: Tag, properties?: Map<Tag, any>, source?: Source, tag?: string): string;
 
     /**
      * Update the property of an instance
@@ -474,9 +502,8 @@ export class Transaction {
      * Change the source of all instances created in this transaction
      *
      * `source` can be specified as :
-     * 1. the orchestrator ('server'),
-     * 2. local ('self') or
-     * 3. an external data source (Tag of a `DBConnector`)
+     * 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.
      *
@@ -485,7 +512,7 @@ export class Transaction {
      * @param source the new source for instances
      * @return this transaction
      */
-    setSource(source: string): this;
+    setSource(source: Source): this;
 
     /**
      * Retrieve the tag of the model of the instance tag
@@ -495,7 +522,7 @@ export class Transaction {
      * @param tag the instance to find the model of
      * @return the tag of the model of the given instance
      */
-    model(tag: Tag): string;
+    model(tag: Tag): string | null;
 
     /**
      * Add all operations of another transaction into this transaction
@@ -516,21 +543,21 @@ export class Transaction {
     afterExecution(callback: (success: boolean, message?: string) => void): this;
 
     /**
-     * Execute atomically the transaction at the source
+     * Execute atomically the transaction at the data sources. Return the transaction result if succeeds.
      *
-     * @return promise resolving if the transaction succeeds,
+     * @return promise resolving with the corresponding TransactionResult if the transaction succeeds,
      * rejecting if the transaction fails
      */
-    execute(): Promise<void>;
+    execute(): Promise<TransactionResult>;
 
     /**
-     * Execute atomically a transaction at the source
+     * Execute atomically a transaction at the data source and returns the transaction result if succeeds.
      * The `large` mode sends the transaction over HTTP
      *
-     * @return promise resolving if the transaction succeeds,
+     * @return promise resolving with the corresponding TransactionResult if the transaction succeeds,
      * rejecting if the transaction fails.
      */
-    executeAsLarge(): Promise<void>;
+    executeAsLarge(): Promise<TransactionResult>;
 
     /**
      * Start a transaction using an existing transaction in the provided context
@@ -551,6 +578,41 @@ export class Transaction {
     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.
@@ -608,7 +670,7 @@ export class QueryResult<T extends CloudObject | CloudObject[]> {
     static empty(): QueryResult<any>;
 
     /**
-     * Symbol iterator for `for..in` syntactic sugar
+     * Symbol iterator for `for…in` syntactic sugar
      *
      * @return iterator over the key-values pairs of this `QueryResult`
      */
@@ -890,18 +952,29 @@ export class Query<T extends CloudObject, R> {
      * @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 Tag>(tag: T, source?: string): Query<T extends CloudObject ? T : CloudObject, never>;
+    static from<T extends Tag>(tag: T, source?: Source): Query<T extends CloudObject ? T : CloudObject, never>;
 
     /**
-     * Create a query starting from the instances of the specified model
+     * 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 Tag>(model: Class<T> | Tag, source?: string): Query<T extends CloudObject ? T : CloudObject, never>;
+    static instancesOf<T extends Tag>(model: Class<T> | Tag, 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
+     */
+    static followRule<T extends Tag>(ctx: Context, root: T, rule: FollowRule, source?: Source): 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.
@@ -914,9 +987,10 @@ export class Query<T extends CloudObject, R> {
      * ```
      *
      * @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>): Query<D, R>;
+    follow<D extends CloudObject>(relation: Relation<T, D>, optional?: boolean): Query<D, R>;
 
     /**
      * Follow a relation recursively, see {@apilink Query.follow}.
@@ -925,9 +999,44 @@ export class Query<T extends CloudObject, R> {
      *
      * @param relation relation to follow recursively, specifies type and direction
      * @param includeSelf  if a starting node includes itself when the relation loops on itself
+     * @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
      */
-    followRecursively<D extends CloudObject>(relation: Relation<T, D>, includeSelf?: boolean): Query<D, R>;
+    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.
@@ -1012,6 +1121,11 @@ export class Query<T extends CloudObject, R> {
      */
     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 afterwards.
      * In other words, one cannot call execute twice on the same `Query`.
@@ -1105,6 +1219,14 @@ export class QuerySingle<T extends CloudObject> {
  * ```
  */
 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: Tag[]): Predicate;
+
     /**
      * Create a predicate matching a specified property to a specified value.
      *
@@ -1119,7 +1241,7 @@ export class Predicate {
      *
      * @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
+     * @param caseSensitive if the match must pay attention to case sensitivity, default value is false
      * @return new Predicate with the contains string operation
      */
     static contains(property: Property<string>, value: string, caseSensitive?: boolean): Predicate;
@@ -1129,7 +1251,7 @@ export class Predicate {
      *
      * @param property the string property to use for filtering
      * @param value the regex the string property must match
-     * @param caseSensitive if the match must pay attention to case sensitivity
+     * @param caseSensitive if the match must pay attention to case sensitivity, default value is false
      * @return new Predicate with the match regex operation
      */
     static regex(property: Property<string>, value: RegExp, caseSensitive?: boolean): Predicate;
@@ -1154,6 +1276,16 @@ export class Predicate {
      */
     static smallerThan(property: Property<number>, value: number, strict?: boolean): Predicate;
 
+    /**
+     * Create a predicate matching the expected model. If extend=true, the predicate will match
+     * against inherited models as well
+     *
+     * @param expectedModel the expected model
+     * @param extend should the predicate also match against inherited models
+     * @return new Predicate
+     */
+    static instanceOf(expectedModel: Tag, extend: boolean): Predicate;
+
     /**
      * Create a predicate matching a specified number property to a number property lower bound
      *
@@ -1200,32 +1332,328 @@ export class Predicate {
 }
 
 /**
- * Specific predicate class creator for filtering based on relations between objects
- *
- * A path is defined by a list of relations, and an object match the predicate if and only if the patch can be followed
- * to a destination (which might be specified)
+ * The sorting order for a {@apilink QueryPart}.
  */
-export class RelatedTo extends Predicate {
-    constructor(destination?: Tag);
+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 {
 
     /**
-     * Adds a relation to the path the RelatedTo predicate must match
-     *
-     * @param relation relation to add to the path
-     * @return new RelatedTo predicate with additional relation to match in the path
+     * 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.
      */
-    follow(relation: Relation<any, any>): RelatedTo;
+    static fromQuery(query: Query<CloudObject, any>): DataResult;
 
     /**
-     * Adds a relation that can be followed recursively in the path for the RelatedTo predicate
-     *
-     * @param relation relation to add to the path that can be followed recursively
-     * @return new RelatedTo predicate with additional relation that can be matched recursively in the path
+     * Create a new Data Type instance with the specified {@apilink Tag}, 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.
      */
-    followRecursive(relation: Relation<any, any>): RelatedTo;
+    create(tag: Tag, model: Tag, properties?: Map<Tag, 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: Tag, from: Tag, to: Tag): this;
 }
 
-export enum Order {
-    ASC,
-    DESC
+/**
+ * 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: string,
+        /** 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.
+ * @abstract
+ * @extends {@apilink CloudObject}
+ */
+export abstract class DataSource extends CloudObject {
+
+    /**
+     * Returns the tag of the data source.
+     * @return {string} tag of the data source.
+     */
+    getId(): string;
+
+    /**
+     * Retrieves the configuration value associated with the provided key in the data source oConfig.
+     * @param {string} 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} 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): Promise<void>;
+
+    /**
+     * Performs a health check on the data source, checking if the connection is alive.
+     * @return {Promise<void>} A Promise that resolves when the health check is completed successfully, rejects otherwise.
+     */
+    protected healthCheck(): Promise<void>;
+
+    /**
+     * Disconnects the data source.
+     * @return {Promise<void>} 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<CloudObject, any>} query - The {@apilink Query} object to execute.
+     * @return {Promise<DataResult>} 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 {Operation[]} transaction - The {@apilink Operation} array to apply.
+     * @return {Promise<void>} A Promise that resolves when the transaction is completed. Rejects when the transaction fails.
+     */
+    protected applyTransaction(transaction: Operation[]): Promise<void>;
+
+    /**
+     * Uploads one file's content to the data source.
+     * @param {string} fileTag - The tag of the file.
+     * @param {string} dataType - The file data type
+     * @param {Uint8Array} binary - The binary data of the file.
+     * @return {Promise<void>} 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 {string} fileTag - The tag of the file.
+     * @param {string} dataType - The file data type
+     * @return {Promise<Uint8Array>} A Promise that resolves with the binary data of the file as a Uint8Array. Rejects otherwise.
+     */
+    protected downloadFileContent(fileTag: string, dataType: string): Promise<Uint8Array>;
+
+    /**
+     * Deletes file content from the data source.
+     * @param {string} fileTag - The tag of the file.
+     * @param {string} dataType - The file data type
+     * @return {Promise<void>} A Promise that resolves when the file content is successfully deleted. Rejects otherwise.
+     */
+    protected deleteFileContent(fileTag: string, dataType: string): Promise<void>;
 }