```
/*
* Saves a set of rules which can later be used under the specified id.
*
* @param id: The id of the new rule set (can be any string).
* @param override: If set to trua and a set of rules already exists for this id, it will be overridden.
* @param rules: An array of rules (see below for possible options).
*
* @returns true if the rules-set was successfully saved.
*/
public async setRules(
id: string,
override: boolean,
rules: RULE[],
): Promise<boolean> {
...
}
```

Objects in the format of the following rules are valid:

```
/*
* The "PERCENTAGE" rule maps the values of the corresponding property from [minRuleValue, maxRuleValue] to [0, 1].
*
* @field type: The rule's type.
* @field minRuleValue (OPTIONAL): The lower bound of the source value range. Defaults to the lowest value of the property, if not specified and 'clamping' is true. Defaults to 0 otherwise.
* @field maxRuleValue (OPTIONAL): The upper bound of the source value range. Defaults to the hightest value of the property, if not specified.
* @field clamping (OPTIONAL): Specifies whether clamping should be applied or not, if no 'minRuleValue' is specified.
*
* Formulas:
* Clamping:
* clampedValue = max(min(value, maxRuleValue), minRuleValue)
* Normalizing:
* normalizedValue = (clampedValue - minRuleValue) / (maxRuleValue - minRuleValue)
*/
interface PERCENTAGE_RULE extends RULE {
type: 'PERCENTAGE';
minRuleValue?: number;
maxRuleValue?: number;
clamping?: boolean;
}
```

```
/*
* The "INVERSE_PERCENTAGE" rule works like the "PERCENTAGE" rule, but inverted (i.e. mapping from [minRuleValue, maxRuleValue] to [1, 0]).
*
* @field type: The rule's type.
* @field minRuleValue (OPTIONAL): see "PERCENTAGE" rule.
* @field maxRuleValue (OPTIONAL): see "PERCENTAGE" rule.
* @field clamping (OPTIONAL): see "PERCENTAGE" rule.
*/
interface INVERSE_PERCENTAGE_RULE extends RULE {
type: 'INVERSE_PERCENTAGE';
minRuleValue?: number;
maxRuleValue?: number;
clamping?: boolean;
}
```

```
/*
* The "EQUALS" rule calculates the score-difference between a row's property's value and the property's value in the 'searchData' of a 'danubePrediction' call, based on the 'equalityScores' in the rule. A lower score-difference gets a higher ranking than a higher score-difference.
*
* @field type: The rule's type.
* @field equalityScores: An array of equality scores.
*/
interface EQUALS_RULE extends RULE {
type: 'EQUALS';
equalityScores: EQUALITY_SCORE[];
}
/*
* An EQUALITY_SCORE maps a possible property value to a score.
*
* @field value: A possible value of the property.
* @field score: The corresponding score for this value.
*/
interface EQUALITY_SCORE {
value: string,
score: number,
}
```

```
/*
* The "OVERLAP_LOCAL" rule calculates the amount of overlap between the values of the property in the 'searchData' of a 'danubePrediction' call and
* the values of a row's property.
*
* @field type: The rule's type.
*/
interface OVERLAP_LOCAL_RULE extends RULE {
type: 'OVERLAP_LOCAL';
}
```

```
/*
* The "OVERLAP_GLOBAL" rule calculates the amount of overlap between the values of the property in the 'searchData' of a 'danubePrediction' call and
* the values in a row's property. Additionally, the overlaps are normalized by the globally highest absolute overlap.
*
* @field type: The rule's type.
*/
interface OVERLAP_GLOBAL_RULE extends RULE {
type: 'OVERLAP_GLOBAL';
}
```