merged with master

45 files changed, 12009 insertions, 0 deletions

diff --git a/src/client/northstar/core/BaseObject.ts b/src/client/northstar/core/BaseObject.ts
new file mode 100644
index 000000000..e9e766e31
--- /dev/null
+++ b/src/client/northstar/core/BaseObject.ts
@@ -0,0 +1,12 @@
+import { IEquatable } from '../utils/IEquatable'
+import { IDisposable } from '../utils/IDisposable'
+
+export class BaseObject implements IEquatable, IDisposable {
+
+    public Equals(other: Object): boolean {
+        return this == other;
+    }
+
+    public Dispose(): void {
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/attribute/AttributeModel.ts b/src/client/northstar/core/attribute/AttributeModel.ts
new file mode 100644
index 000000000..124a5b45a
--- /dev/null
+++ b/src/client/northstar/core/attribute/AttributeModel.ts
@@ -0,0 +1,111 @@
+import { Attribute, DataType, VisualizationHint } from '../../model/idea/idea'
+import { BaseObject } from '../BaseObject'
+import { observable } from "mobx";
+
+export abstract class AttributeModel extends BaseObject {
+    public abstract get DisplayName(): string;
+    public abstract get CodeName(): string;
+    public abstract get DataType(): DataType;
+    public abstract get VisualizationHints(): VisualizationHint[];
+}
+
+export class ColumnAttributeModel extends AttributeModel {
+    public Attribute: Attribute;
+
+    constructor(attribute: Attribute) {
+        super();
+        this.Attribute = attribute;
+    }
+
+    public get DataType(): DataType {
+        return this.Attribute.dataType ? this.Attribute.dataType : DataType.Undefined;
+    }
+
+    public get DisplayName(): string {
+        return this.Attribute.displayName ? this.Attribute.displayName.ReplaceAll("_", " ") : "";
+    }
+
+    public get CodeName(): string {
+        return this.Attribute.rawName ? this.Attribute.rawName : "";
+    }
+
+    public get VisualizationHints(): VisualizationHint[] {
+        return this.Attribute.visualizationHints ? this.Attribute.visualizationHints : [];
+    }
+
+    public Equals(other: ColumnAttributeModel): boolean {
+        return this.Attribute.rawName == other.Attribute.rawName;
+    }
+}
+
+export class CodeAttributeModel extends AttributeModel {
+    private _visualizationHints: VisualizationHint[];
+
+    public CodeName: string;
+
+    @observable
+    public Code: string;
+
+    constructor(code: string, codeName: string, displayName: string, visualizationHints: VisualizationHint[]) {
+        super();
+        this.Code = code;
+        this.CodeName = codeName;
+        this.DisplayName = displayName;
+        this._visualizationHints = visualizationHints;
+    }
+
+    public get DataType(): DataType {
+        return DataType.Undefined;
+    }
+
+    @observable
+    public DisplayName: string;
+
+    public get VisualizationHints(): VisualizationHint[] {
+        return this._visualizationHints;
+    }
+
+    public Equals(other: CodeAttributeModel): boolean {
+        return this.CodeName === other.CodeName;
+    }
+
+}
+
+export class BackendAttributeModel extends AttributeModel {
+    private _dataType: DataType;
+    private _displayName: string;
+    private _codeName: string;
+    private _visualizationHints: VisualizationHint[];
+
+    public Id: string;
+
+    constructor(id: string, dataType: DataType, displayName: string, codeName: string, visualizationHints: VisualizationHint[]) {
+        super();
+        this.Id = id;
+        this._dataType = dataType;
+        this._displayName = displayName;
+        this._codeName = codeName;
+        this._visualizationHints = visualizationHints;
+    }
+
+    public get DataType(): DataType {
+        return this._dataType;
+    }
+
+    public get DisplayName(): string {
+        return this._displayName.ReplaceAll("_", " ");;
+    }
+
+    public get CodeName(): string {
+        return this._codeName;
+    }
+
+    public get VisualizationHints(): VisualizationHint[] {
+        return this._visualizationHints;
+    }
+
+    public Equals(other: BackendAttributeModel): boolean {
+        return this.Id == other.Id;
+    }
+
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/attribute/AttributeTransformationModel.ts b/src/client/northstar/core/attribute/AttributeTransformationModel.ts
new file mode 100644
index 000000000..cc5aa7154
--- /dev/null
+++ b/src/client/northstar/core/attribute/AttributeTransformationModel.ts
@@ -0,0 +1,47 @@
+;
+import { computed, observable } from "mobx";
+import { AggregateFunction } from "../../model/idea/idea";
+import { AttributeModel } from "./AttributeModel";
+import { IEquatable } from "../../utils/IEquatable";
+
+export class AttributeTransformationModel implements IEquatable {
+
+    @observable public AggregateFunction: AggregateFunction;
+    @observable public AttributeModel: AttributeModel;
+
+    constructor(attributeModel: AttributeModel, aggregateFunction: AggregateFunction = AggregateFunction.None) {
+        this.AttributeModel = attributeModel;
+        this.AggregateFunction = aggregateFunction;
+    }
+
+    @computed
+    public get PresentedName(): string {
+        var displayName = this.AttributeModel.DisplayName;
+        if (this.AggregateFunction === AggregateFunction.Count) {
+            return "count";
+        }
+        if (this.AggregateFunction === AggregateFunction.Avg)
+            displayName = "avg(" + displayName + ")";
+        else if (this.AggregateFunction === AggregateFunction.Max)
+            displayName = "max(" + displayName + ")";
+        else if (this.AggregateFunction === AggregateFunction.Min)
+            displayName = "min(" + displayName + ")";
+        else if (this.AggregateFunction === AggregateFunction.Sum)
+            displayName = "sum(" + displayName + ")";
+        else if (this.AggregateFunction === AggregateFunction.SumE)
+            displayName = "sumE(" + displayName + ")";
+
+        return displayName;
+    }
+
+    public clone(): AttributeTransformationModel {
+        var clone = new AttributeTransformationModel(this.AttributeModel);
+        clone.AggregateFunction = this.AggregateFunction;
+        return clone;
+    }
+
+    public Equals(other: AttributeTransformationModel): boolean {
+        return this.AggregateFunction == other.AggregateFunction &&
+            this.AttributeModel.Equals(other.AttributeModel);
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/attribute/CalculatedAttributeModel.ts b/src/client/northstar/core/attribute/CalculatedAttributeModel.ts
new file mode 100644
index 000000000..ab96c794d
--- /dev/null
+++ b/src/client/northstar/core/attribute/CalculatedAttributeModel.ts
@@ -0,0 +1,42 @@
+import { BackendAttributeModel, AttributeModel, CodeAttributeModel } from "./AttributeModel";
+import { DataType, VisualizationHint } from '../../model/idea/idea'
+
+export class CalculatedAttributeManager {
+    public static AllCalculatedAttributes: Array<AttributeModel> = new Array<AttributeModel>();
+
+    public static Clear() {
+        this.AllCalculatedAttributes = new Array<AttributeModel>();
+    }
+
+    public static CreateBackendAttributeModel(id: string, dataType: DataType, displayName: string, codeName: string, visualizationHints: VisualizationHint[]): BackendAttributeModel {
+        var filtered = this.AllCalculatedAttributes.filter(am => {
+            if (am instanceof BackendAttributeModel &&
+                am.Id == id) {
+                return true;
+            }
+            return false;
+        });
+        if (filtered.length > 0) {
+            return filtered[0] as BackendAttributeModel;
+        }
+        var newAttr = new BackendAttributeModel(id, dataType, displayName, codeName, visualizationHints);
+        this.AllCalculatedAttributes.push(newAttr);
+        return newAttr;
+    }
+
+    public static CreateCodeAttributeModel(code: string, codeName: string, visualizationHints: VisualizationHint[]): CodeAttributeModel {
+        var filtered = this.AllCalculatedAttributes.filter(am => {
+            if (am instanceof CodeAttributeModel &&
+                am.CodeName == codeName) {
+                return true;
+            }
+            return false;
+        });
+        if (filtered.length > 0) {
+            return filtered[0] as CodeAttributeModel;
+        }
+        var newAttr = new CodeAttributeModel(code, codeName, codeName.ReplaceAll("_", " "), visualizationHints);
+        this.AllCalculatedAttributes.push(newAttr);
+        return newAttr;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/brusher/IBaseBrushable.ts b/src/client/northstar/core/brusher/IBaseBrushable.ts
new file mode 100644
index 000000000..99a36636f
--- /dev/null
+++ b/src/client/northstar/core/brusher/IBaseBrushable.ts
@@ -0,0 +1,13 @@
+import { PIXIPoint } from '../../utils/MathUtil'
+import { IEquatable } from '../../utils/IEquatable';
+import { Document } from '../../../../fields/Document'
+
+export interface IBaseBrushable<T> extends IEquatable {
+    BrusherModels: Array<Document>;
+    BrushColors: Array<number>;
+    Position: PIXIPoint;
+    Size: PIXIPoint;
+}
+export function instanceOfIBaseBrushable<T>(object: any): object is IBaseBrushable<T> {
+    return 'BrusherModels' in object;
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/brusher/IBaseBrusher.ts b/src/client/northstar/core/brusher/IBaseBrusher.ts
new file mode 100644
index 000000000..d7ae65464
--- /dev/null
+++ b/src/client/northstar/core/brusher/IBaseBrusher.ts
@@ -0,0 +1,11 @@
+import { PIXIPoint } from '../../utils/MathUtil'
+import { IEquatable } from '../../utils/IEquatable';
+
+
+export interface IBaseBrusher<T> extends IEquatable {
+    Position: PIXIPoint;
+    Size: PIXIPoint;
+}
+export function instanceOfIBaseBrusher<T>(object: any): object is IBaseBrusher<T> {
+    return 'BrushableModels' in object;
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/FilterModel.ts b/src/client/northstar/core/filter/FilterModel.ts
new file mode 100644
index 000000000..aee99d2b6
--- /dev/null
+++ b/src/client/northstar/core/filter/FilterModel.ts
@@ -0,0 +1,84 @@
+import { ValueComparison } from "./ValueComparision";
+import { Utils } from "../../utils/Utils";
+import { IBaseFilterProvider } from "./IBaseFilterProvider";
+import { FilterOperand } from "./FilterOperand";
+import { KeyStore } from "../../../../fields/KeyStore";
+import { FieldWaiting } from "../../../../fields/Field";
+import { Document } from "../../../../fields/Document";
+import { HistogramField } from "../../dash-fields/HistogramField";
+
+export class FilterModel {
+    public ValueComparisons: ValueComparison[];
+    constructor() {
+        this.ValueComparisons = new Array<ValueComparison>();
+    }
+
+    public Equals(other: FilterModel): boolean {
+        if (!Utils.EqualityHelper(this, other)) return false;
+        if (!this.isSame(this.ValueComparisons, (other as FilterModel).ValueComparisons)) return false;
+        return true;
+    }
+
+    private isSame(a: ValueComparison[], b: ValueComparison[]): boolean {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            let valueComp = a[i];
+            if (!valueComp.Equals(b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public ToPythonString(): string {
+        return "(" + this.ValueComparisons.map(vc => vc.ToPythonString()).join("&&") + ")";
+    }
+
+    public static And(filters: string[]): string {
+        let ret = filters.filter(f => f !== "").join(" && ");
+        return ret;
+    }
+    public static GetFilterModelsRecursive(baseOperation: IBaseFilterProvider, visitedFilterProviders: Set<IBaseFilterProvider>, filterModels: FilterModel[], isFirst: boolean): string {
+        let ret = "";
+        visitedFilterProviders.add(baseOperation);
+        let filtered = baseOperation.FilterModels.filter(fm => fm && fm.ValueComparisons.length > 0);
+        if (!isFirst && filtered.length > 0) {
+            filterModels.push(...filtered);
+            ret = "(" + baseOperation.FilterModels.filter(fm => fm != null).map(fm => fm.ToPythonString()).join(" || ") + ")";
+        }
+        if (Utils.isBaseFilterConsumer(baseOperation) && baseOperation.Links) {
+            let children = new Array<string>();
+            let linkedGraphNodes = baseOperation.Links;
+            linkedGraphNodes.map(linkVm => {
+                let filterDoc = linkVm.Get(KeyStore.LinkedFromDocs);
+                if (filterDoc && filterDoc != FieldWaiting && filterDoc instanceof Document) {
+                    let filterHistogram = filterDoc.GetT(KeyStore.Data, HistogramField);
+                    if (filterHistogram && filterHistogram != FieldWaiting) {
+                        if (!visitedFilterProviders.has(filterHistogram.Data)) {
+                            let child = FilterModel.GetFilterModelsRecursive(filterHistogram.Data, visitedFilterProviders, filterModels, false);
+                            if (child !== "") {
+                                // if (linkVm.IsInverted) {
+                                //     child = "! " + child;
+                                // }
+                                children.push(child);
+                            }
+                        }
+                    }
+                }
+            });
+
+            let childrenJoined = children.join(baseOperation.FilterOperand === FilterOperand.AND ? " && " : " || ");
+            if (children.length > 0) {
+                if (ret !== "") {
+                    ret = "(" + ret + " &&  (" + childrenJoined + "))";
+                }
+                else {
+                    ret = "(" + childrenJoined + ")";
+                }
+            }
+        }
+        return ret;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/FilterOperand.ts b/src/client/northstar/core/filter/FilterOperand.ts
new file mode 100644
index 000000000..2e8e8d6a0
--- /dev/null
+++ b/src/client/northstar/core/filter/FilterOperand.ts
@@ -0,0 +1,5 @@
+export enum FilterOperand
+{
+    AND,
+    OR
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/FilterType.ts b/src/client/northstar/core/filter/FilterType.ts
new file mode 100644
index 000000000..9adbc087f
--- /dev/null
+++ b/src/client/northstar/core/filter/FilterType.ts
@@ -0,0 +1,6 @@
+export enum FilterType
+{
+    Filter,
+    Brush,
+    Slice
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/IBaseFilterConsumer.ts b/src/client/northstar/core/filter/IBaseFilterConsumer.ts
new file mode 100644
index 000000000..93f66a154
--- /dev/null
+++ b/src/client/northstar/core/filter/IBaseFilterConsumer.ts
@@ -0,0 +1,12 @@
+import { FilterOperand } from '../filter/FilterOperand'
+import { IEquatable } from '../../utils/IEquatable'
+import { Document } from "../../../../fields/Document";
+
+export interface IBaseFilterConsumer extends IEquatable {
+    FilterOperand: FilterOperand;
+    Links: Document[];
+}
+
+export function instanceOfIBaseFilterConsumer(object: any): object is IBaseFilterConsumer {
+    return 'FilterOperand' in object;
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/IBaseFilterProvider.ts b/src/client/northstar/core/filter/IBaseFilterProvider.ts
new file mode 100644
index 000000000..d082bfe12
--- /dev/null
+++ b/src/client/northstar/core/filter/IBaseFilterProvider.ts
@@ -0,0 +1,8 @@
+import { FilterModel } from '../filter/FilterModel'
+
+export interface IBaseFilterProvider {
+    FilterModels: Array<FilterModel>;
+}
+export function instanceOfIBaseFilterProvider(object: any): object is IBaseFilterProvider {
+    return 'FilterModels' in object;
+}
\ No newline at end of file
diff --git a/src/client/northstar/core/filter/ValueComparision.ts b/src/client/northstar/core/filter/ValueComparision.ts
new file mode 100644
index 000000000..1e729d06e
--- /dev/null
+++ b/src/client/northstar/core/filter/ValueComparision.ts
@@ -0,0 +1,74 @@
+import { Predicate } from '../../model/idea/idea'
+import { Utils } from '../../utils/Utils'
+import { AttributeModel } from '../attribute/AttributeModel';
+
+export class ValueComparison {
+
+    public attributeModel: AttributeModel;
+    public Value: any;
+    public Predicate: Predicate;
+
+    public constructor(attributeModel: AttributeModel, predicate: Predicate, value: any) {
+        this.attributeModel = attributeModel;
+        this.Value = value;
+        this.Predicate = predicate;
+    }
+
+    public Equals(other: Object): boolean {
+        if (!Utils.EqualityHelper(this, other))
+            return false;
+        if (this.Predicate !== (other as ValueComparison).Predicate)
+            return false;
+        let isComplex = (typeof this.Value === "object");
+        if (!isComplex && this.Value != (other as ValueComparison).Value)
+            return false;
+        if (isComplex && !this.Value.Equals((other as ValueComparison).Value))
+            return false;
+        return true;
+    }
+
+    public ToPythonString(): string {
+        var op = "";
+        switch (this.Predicate) {
+            case Predicate.EQUALS:
+                op = "==";
+                break;
+            case Predicate.GREATER_THAN:
+                op = ">";
+                break;
+            case Predicate.GREATER_THAN_EQUAL:
+                op = ">=";
+                break;
+            case Predicate.LESS_THAN:
+                op = "<";
+                break;
+            case Predicate.LESS_THAN_EQUAL:
+                op = "<=";
+                break;
+            default:
+                op = "==";
+                break;
+        }
+
+        var val = this.Value.toString();
+        if (typeof this.Value === 'string' || this.Value instanceof String) {
+            val = "\"" + val + "\"";
+        }
+        var ret = " ";
+        var rawName = this.attributeModel.CodeName;
+        switch (this.Predicate) {
+            case Predicate.STARTS_WITH:
+                ret += rawName + " != null && " + rawName + ".StartsWith(" + val + ") ";
+                return ret;
+            case Predicate.ENDS_WITH:
+                ret += rawName + " != null && " + rawName + ".EndsWith(" + val + ") ";
+                return ret;
+            case Predicate.CONTAINS:
+                ret += rawName + " != null && " + rawName + ".Contains(" + val + ") ";
+                return ret;
+            default:
+                ret += rawName + " " + op + " " + val + " ";
+                return ret;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/dash-fields/HistogramField.ts b/src/client/northstar/dash-fields/HistogramField.ts
new file mode 100644
index 000000000..90be70b80
--- /dev/null
+++ b/src/client/northstar/dash-fields/HistogramField.ts
@@ -0,0 +1,73 @@
+import { action } from "mobx";
+import { ColumnAttributeModel } from "../../../client/northstar/core/attribute/AttributeModel";
+import { AttributeTransformationModel } from "../../../client/northstar/core/attribute/AttributeTransformationModel";
+import { HistogramOperation } from "../../../client/northstar/operations/HistogramOperation";
+import { BasicField } from "../../../fields/BasicField";
+import { Field, FieldId } from "../../../fields/Field";
+import { CurrentUserUtils } from "../../../server/authentication/models/current_user_utils";
+import { Types } from "../../../server/Message";
+
+
+export class HistogramField extends BasicField<HistogramOperation> {
+    constructor(data?: HistogramOperation, id?: FieldId, save: boolean = true) {
+        super(data ? data : HistogramOperation.Empty, save, id);
+    }
+
+    omitKeys(obj: any, keys: any) {
+        var dup: any = {};
+        for (var key in obj) {
+            if (keys.indexOf(key) == -1) {
+                dup[key] = obj[key];
+            }
+        }
+        return dup;
+    }
+    toString(): string {
+        return JSON.stringify(this.omitKeys(this.Data, ['Links', 'BrushLinks', 'Result', 'BrushColors', 'FilterModels', 'FilterOperand']));
+    }
+
+    Copy(): Field {
+        return new HistogramField(this.Data);
+    }
+
+    ToScriptString(): string {
+        return `new HistogramField("${this.Data}")`;
+    }
+
+
+    ToJson(): { type: Types, data: string, _id: string } {
+        return {
+            type: Types.HistogramOp,
+
+            data: this.toString(),
+            _id: this.Id
+        }
+    }
+
+    @action
+    static FromJson(id: string, data: any): HistogramField {
+        let jp = JSON.parse(data);
+        let X: AttributeTransformationModel | undefined;
+        let Y: AttributeTransformationModel | undefined;
+        let V: AttributeTransformationModel | undefined;
+
+        let schema = CurrentUserUtils.GetNorthstarSchema(jp.SchemaName);
+        if (schema) {
+            CurrentUserUtils.GetAllNorthstarColumnAttributes(schema).map(attr => {
+                if (attr.displayName == jp.X.AttributeModel.Attribute.DisplayName) {
+                    X = new AttributeTransformationModel(new ColumnAttributeModel(attr), jp.X.AggregateFunction);
+                }
+                if (attr.displayName == jp.Y.AttributeModel.Attribute.DisplayName) {
+                    Y = new AttributeTransformationModel(new ColumnAttributeModel(attr), jp.Y.AggregateFunction);
+                }
+                if (attr.displayName == jp.V.AttributeModel.Attribute.DisplayName) {
+                    V = new AttributeTransformationModel(new ColumnAttributeModel(attr), jp.V.AggregateFunction);
+                }
+            });
+            if (X && Y && V) {
+                return new HistogramField(new HistogramOperation(jp.SchemaName, X, Y, V, jp.Normalization), id, false);
+            }
+        }
+        return new HistogramField(HistogramOperation.Empty, id, false);
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramBinPrimitiveCollection.ts b/src/client/northstar/dash-nodes/HistogramBinPrimitiveCollection.ts
new file mode 100644
index 000000000..43e768c62
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramBinPrimitiveCollection.ts
@@ -0,0 +1,238 @@
+import React = require("react")
+import { AttributeTransformationModel } from "../../northstar/core/attribute/AttributeTransformationModel";
+import { ChartType } from '../../northstar/model/binRanges/VisualBinRange';
+import { AggregateFunction, Bin, Brush, DoubleValueAggregateResult, HistogramResult, MarginAggregateParameters, MarginAggregateResult } from "../../northstar/model/idea/idea";
+import { ModelHelpers } from "../../northstar/model/ModelHelpers";
+import { LABColor } from '../../northstar/utils/LABcolor';
+import { PIXIRectangle } from "../../northstar/utils/MathUtil";
+import { StyleConstants } from "../../northstar/utils/StyleContants";
+import { HistogramBox } from "./HistogramBox";
+import "./HistogramBoxPrimitives.scss";
+
+export class HistogramBinPrimitive {
+    constructor(init?: Partial<HistogramBinPrimitive>) {
+        Object.assign(this, init);
+    }
+    public DataValue: number = 0;
+    public Rect: PIXIRectangle = PIXIRectangle.EMPTY;
+    public MarginRect: PIXIRectangle = PIXIRectangle.EMPTY;
+    public MarginPercentage: number = 0;
+    public Color: number = StyleConstants.WARNING_COLOR;
+    public Opacity: number = 1;
+    public BrushIndex: number = 0;
+    public BarAxis: number = -1;
+}
+
+export class HistogramBinPrimitiveCollection {
+    private static TOLERANCE: number = 0.0001;
+
+    private _histoBox: HistogramBox;
+    private get histoOp() { return this._histoBox.HistoOp; }
+    private get histoResult() { return this.histoOp.Result as HistogramResult; }
+    private get sizeConverter() { return this._histoBox.SizeConverter!; }
+    public BinPrimitives: Array<HistogramBinPrimitive> = new Array<HistogramBinPrimitive>();
+    public HitGeom: PIXIRectangle = PIXIRectangle.EMPTY;
+
+    constructor(bin: Bin, histoBox: HistogramBox) {
+        this._histoBox = histoBox;
+        let brushing = this.setupBrushing(bin, this.histoOp.Normalization); // X= 0, Y = 1, V = 2
+
+        brushing.orderedBrushes.reduce((brushFactorSum, brush) => {
+            switch (histoBox.ChartType) {
+                case ChartType.VerticalBar: return this.createVerticalBarChartBinPrimitives(bin, brush, brushing.maxAxis, this.histoOp.Normalization);
+                case ChartType.HorizontalBar: return this.createHorizontalBarChartBinPrimitives(bin, brush, brushing.maxAxis, this.histoOp.Normalization);
+                case ChartType.SinglePoint: return this.createSinglePointChartBinPrimitives(bin, brush);
+                case ChartType.HeatMap: return this.createHeatmapBinPrimitives(bin, brush, brushFactorSum);
+            }
+        }, 0);
+
+        // adjust brush rects (stacking or not)
+        var allBrushIndex = ModelHelpers.AllBrushIndex(this.histoResult);
+        var filteredBinPrims = this.BinPrimitives.filter(b => b.BrushIndex != allBrushIndex && b.DataValue != 0.0);
+        filteredBinPrims.reduce((sum, fbp) => {
+            if (histoBox.ChartType == ChartType.VerticalBar) {
+                if (this.histoOp.Y.AggregateFunction == AggregateFunction.Count) {
+                    fbp.Rect = new PIXIRectangle(fbp.Rect.x, fbp.Rect.y - sum, fbp.Rect.width, fbp.Rect.height);
+                    fbp.MarginRect = new PIXIRectangle(fbp.MarginRect.x, fbp.MarginRect.y - sum, fbp.MarginRect.width, fbp.MarginRect.height);
+                    return sum + fbp.Rect.height;
+                }
+                if (this.histoOp.Y.AggregateFunction == AggregateFunction.Avg) {
+                    var w = fbp.Rect.width / 2.0;
+                    fbp.Rect = new PIXIRectangle(fbp.Rect.x + sum, fbp.Rect.y, fbp.Rect.width / filteredBinPrims.length, fbp.Rect.height);
+                    fbp.MarginRect = new PIXIRectangle(fbp.MarginRect.x - w + sum + (fbp.Rect.width / 2.0), fbp.MarginRect.y, fbp.MarginRect.width, fbp.MarginRect.height);
+                    return sum + fbp.Rect.width;
+                }
+            }
+            else if (histoBox.ChartType == ChartType.HorizontalBar) {
+                if (this.histoOp.X.AggregateFunction == AggregateFunction.Count) {
+                    fbp.Rect = new PIXIRectangle(fbp.Rect.x + sum, fbp.Rect.y, fbp.Rect.width, fbp.Rect.height);
+                    fbp.MarginRect = new PIXIRectangle(fbp.MarginRect.x + sum, fbp.MarginRect.y, fbp.MarginRect.width, fbp.MarginRect.height);
+                    return sum + fbp.Rect.width;
+                }
+                if (this.histoOp.X.AggregateFunction == AggregateFunction.Avg) {
+                    var h = fbp.Rect.height / 2.0;
+                    fbp.Rect = new PIXIRectangle(fbp.Rect.x, fbp.Rect.y + sum, fbp.Rect.width, fbp.Rect.height / filteredBinPrims.length);
+                    fbp.MarginRect = new PIXIRectangle(fbp.MarginRect.x, fbp.MarginRect.y - h + sum + (fbp.Rect.height / 2.0), fbp.MarginRect.width, fbp.MarginRect.height);
+                    return sum + fbp.Rect.height;
+                }
+            }
+            return 0;
+        }, 0);
+        this.BinPrimitives = this.BinPrimitives.reverse();
+        var f = this.BinPrimitives.filter(b => b.BrushIndex == allBrushIndex);
+        this.HitGeom = f.length > 0 ? f[0].Rect : PIXIRectangle.EMPTY;
+    }
+
+    private setupBrushing(bin: Bin, normalization: number) {
+        var overlapBrushIndex = ModelHelpers.OverlapBrushIndex(this.histoResult);
+        var orderedBrushes = [this.histoResult.brushes![0], this.histoResult.brushes![overlapBrushIndex]];
+        this.histoResult.brushes!.map(brush => brush.brushIndex != 0 && brush.brushIndex != overlapBrushIndex && orderedBrushes.push(brush));
+        return {
+            orderedBrushes,
+            maxAxis: orderedBrushes.reduce((prev, Brush) => {
+                let aggResult = this.getBinValue(normalization, bin, Brush.brushIndex!);
+                return aggResult != undefined && aggResult > prev ? aggResult : prev;
+            }, Number.MIN_VALUE)
+        };
+    }
+
+    private createHeatmapBinPrimitives(bin: Bin, brush: Brush, brushFactorSum: number): number {
+
+        let unNormalizedValue = this.getBinValue(2, bin, brush.brushIndex!);
+        if (unNormalizedValue == undefined)
+            return brushFactorSum;
+
+        var normalizedValue = (unNormalizedValue - this._histoBox.ValueRange[0]) / (Math.abs((this._histoBox.ValueRange[1] - this._histoBox.ValueRange[0])) < HistogramBinPrimitiveCollection.TOLERANCE ?
+            unNormalizedValue : this._histoBox.ValueRange[1] - this._histoBox.ValueRange[0]);
+
+        let allUnNormalizedValue = this.getBinValue(2, bin, ModelHelpers.AllBrushIndex(this.histoResult))
+
+        // bcz: are these calls needed?  
+        let [xFrom, xTo] = this.sizeConverter.DataToScreenXAxisRange(this._histoBox.VisualBinRanges, 0, bin);
+        let [yFrom, yTo] = this.sizeConverter.DataToScreenYAxisRange(this._histoBox.VisualBinRanges, 1, bin);
+
+        var returnBrushFactorSum = brushFactorSum;
+        if (allUnNormalizedValue != undefined) {
+            var brushFactor = (unNormalizedValue / allUnNormalizedValue);
+            returnBrushFactorSum += brushFactor;
+            returnBrushFactorSum = Math.min(returnBrushFactorSum, 1.0);
+
+            var tempRect = new PIXIRectangle(xFrom, yTo, xTo - xFrom, yFrom - yTo);
+            var ratio = (tempRect.width / tempRect.height);
+            var newHeight = Math.sqrt((1.0 / ratio) * ((tempRect.width * tempRect.height) * returnBrushFactorSum));
+            var newWidth = newHeight * ratio;
+
+            xFrom = (tempRect.x + (tempRect.width - newWidth) / 2.0);
+            yTo = (tempRect.y + (tempRect.height - newHeight) / 2.0);
+            xTo = (xFrom + newWidth);
+            yFrom = (yTo + newHeight);
+        }
+        var alpha = 0.0;
+        var color = this.baseColorFromBrush(brush);
+        var lerpColor = LABColor.Lerp(
+            LABColor.FromColor(StyleConstants.MIN_VALUE_COLOR),
+            LABColor.FromColor(color),
+            (alpha + Math.pow(normalizedValue, 1.0 / 3.0) * (1.0 - alpha)));
+        var dataColor = LABColor.ToColor(lerpColor);
+
+        this.createBinPrimitive(-1, brush, PIXIRectangle.EMPTY, 0, xFrom, xTo, yFrom, yTo, dataColor, 1, unNormalizedValue);
+        return returnBrushFactorSum;
+    }
+
+    private createSinglePointChartBinPrimitives(bin: Bin, brush: Brush): number {
+        let unNormalizedValue = this.getBinValue(2, bin, brush.brushIndex!);
+        if (unNormalizedValue != undefined) {
+            let [xFrom, xTo] = this.sizeConverter.DataToScreenPointRange(0, bin, ModelHelpers.CreateAggregateKey(this.histoOp.Schema!.distinctAttributeParameters, this.histoOp.X, this.histoResult, brush.brushIndex!));
+            let [yFrom, yTo] = this.sizeConverter.DataToScreenPointRange(1, bin, ModelHelpers.CreateAggregateKey(this.histoOp.Schema!.distinctAttributeParameters, this.histoOp.Y, this.histoResult, brush.brushIndex!));
+
+            if (xFrom != undefined && yFrom != undefined && xTo != undefined && yTo != undefined)
+                this.createBinPrimitive(-1, brush, PIXIRectangle.EMPTY, 0, xFrom, xTo, yFrom, yTo, this.baseColorFromBrush(brush), 1, unNormalizedValue);
+        }
+        return 0;
+    }
+
+    private createVerticalBarChartBinPrimitives(bin: Bin, brush: Brush, binBrushMaxAxis: number, normalization: number): number {
+        let dataValue = this.getBinValue(1, bin, brush.brushIndex!);
+        if (dataValue != undefined) {
+            let [yFrom, yValue, yTo] = this.sizeConverter.DataToScreenNormalizedRange(dataValue, normalization, 1, binBrushMaxAxis);
+            let [xFrom, xTo] = this.sizeConverter.DataToScreenXAxisRange(this._histoBox.VisualBinRanges, 0, bin);
+
+            var yMarginAbsolute = this.getMargin(bin, brush, this.histoOp.Y);
+            var marginRect = new PIXIRectangle(xFrom + (xTo - xFrom) / 2.0 - 1,
+                this.sizeConverter.DataToScreenY(yValue + yMarginAbsolute), 2,
+                this.sizeConverter.DataToScreenY(yValue - yMarginAbsolute) - this.sizeConverter.DataToScreenY(yValue + yMarginAbsolute));
+
+            this.createBinPrimitive(1, brush, marginRect, 0, xFrom, xTo, yFrom, yTo,
+                this.baseColorFromBrush(brush), normalization != 0 ? 1 : 0.6 * binBrushMaxAxis / this.sizeConverter.DataRanges[1] + 0.4, dataValue);
+        }
+        return 0;
+    }
+
+    private createHorizontalBarChartBinPrimitives(bin: Bin, brush: Brush, binBrushMaxAxis: number, normalization: number): number {
+        let dataValue = this.getBinValue(0, bin, brush.brushIndex!);
+        if (dataValue != undefined) {
+            let [xFrom, xValue, xTo] = this.sizeConverter.DataToScreenNormalizedRange(dataValue, normalization, 0, binBrushMaxAxis);
+            let [yFrom, yTo] = this.sizeConverter.DataToScreenYAxisRange(this._histoBox.VisualBinRanges, 1, bin);
+
+            var xMarginAbsolute = this.sizeConverter.IsSmall ? 0 : this.getMargin(bin, brush, this.histoOp.X);
+            var marginRect = new PIXIRectangle(this.sizeConverter.DataToScreenX(xValue - xMarginAbsolute),
+                yTo + (yFrom - yTo) / 2.0 - 1,
+                this.sizeConverter.DataToScreenX(xValue + xMarginAbsolute) - this.sizeConverter.DataToScreenX(xValue - xMarginAbsolute),
+                2.0);
+
+            this.createBinPrimitive(0, brush, marginRect, 0, xFrom, xTo, yFrom, yTo,
+                this.baseColorFromBrush(brush), normalization != 1 ? 1 : 0.6 * binBrushMaxAxis / this.sizeConverter.DataRanges[0] + 0.4, dataValue);
+        }
+        return 0;
+    }
+
+    public getBinValue(axis: number, bin: Bin, brushIndex: number) {
+        var aggregateKey = ModelHelpers.CreateAggregateKey(this.histoOp.Schema!.distinctAttributeParameters, axis == 0 ? this.histoOp.X : axis == 1 ? this.histoOp.Y : this.histoOp.V, this.histoResult, brushIndex);
+        let dataValue = ModelHelpers.GetAggregateResult(bin, aggregateKey) as DoubleValueAggregateResult;
+        return dataValue != null && dataValue.hasResult ? dataValue.result : undefined;
+    }
+
+    private getMargin(bin: Bin, brush: Brush, axis: AttributeTransformationModel) {
+        var marginParams = new MarginAggregateParameters();
+        marginParams.aggregateFunction = axis.AggregateFunction;
+        var marginAggregateKey = ModelHelpers.CreateAggregateKey(this.histoOp.Schema!.distinctAttributeParameters, axis, this.histoResult, brush.brushIndex!, marginParams);
+        var marginResult = ModelHelpers.GetAggregateResult(bin, marginAggregateKey) as MarginAggregateResult;
+        return !marginResult ? 0 : marginResult.absolutMargin!;
+    }
+
+    private createBinPrimitive(barAxis: number, brush: Brush, marginRect: PIXIRectangle,
+        marginPercentage: number, xFrom: number, xTo: number, yFrom: number, yTo: number, color: number, opacity: number, dataValue: number) {
+        var binPrimitive = new HistogramBinPrimitive(
+            {
+                Rect: new PIXIRectangle(xFrom, yTo, xTo - xFrom, yFrom - yTo),
+                MarginRect: marginRect,
+                MarginPercentage: marginPercentage,
+                BrushIndex: brush.brushIndex,
+                Color: color,
+                Opacity: opacity,
+                DataValue: dataValue,
+                BarAxis: barAxis
+            });
+        this.BinPrimitives.push(binPrimitive);
+    }
+
+    private baseColorFromBrush(brush: Brush): number {
+        let bc = StyleConstants.BRUSH_COLORS;
+        if (brush.brushIndex == ModelHelpers.RestBrushIndex(this.histoResult)) {
+            return StyleConstants.HIGHLIGHT_COLOR;
+        }
+        else if (brush.brushIndex == ModelHelpers.OverlapBrushIndex(this.histoResult)) {
+            return StyleConstants.OVERLAP_COLOR;
+        }
+        else if (brush.brushIndex == ModelHelpers.AllBrushIndex(this.histoResult)) {
+            return 0x00ff00;
+        }
+        else if (bc.length > 0) {
+            return bc[brush.brushIndex! % bc.length];
+        }
+        // else if (this.histoOp.BrushColors.length > 0) {
+        //     return this.histoOp.BrushColors[brush.brushIndex! % this.histoOp.BrushColors.length];
+        // }
+        return StyleConstants.HIGHLIGHT_COLOR;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramBox.scss b/src/client/northstar/dash-nodes/HistogramBox.scss
new file mode 100644
index 000000000..b11840a65
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramBox.scss
@@ -0,0 +1,34 @@
+.histogrambox-container {
+    padding: 0vw;
+    position: absolute;
+    text-align: center;
+    width: 100%;
+    height: 100%;
+    background: black;
+  }
+  .histogrambox-xaxislabel {
+    position:absolute;
+    width:100%;
+    text-align: center;
+    bottom:0;
+    background: lightgray;
+    font-size: 14;
+    font-weight: bold;
+  }
+  .histogrambox-yaxislabel {
+    position:absolute;
+    height:100%;
+    width: 25px;
+    bottom:0;
+    background: lightgray;
+  }
+  .histogrambox-yaxislabel-text {
+    position:absolute;
+    transform-origin: left;
+    transform: rotate(-90deg);
+    text-align: center;
+    font-size: 14;
+    font-weight: bold;
+    bottom: calc(50% - 25px);
+  }
+  
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramBox.tsx b/src/client/northstar/dash-nodes/HistogramBox.tsx
new file mode 100644
index 000000000..49ebe5ebc
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramBox.tsx
@@ -0,0 +1,174 @@
+import React = require("react")
+import { action, computed, observable, reaction, runInAction, trace } from "mobx";
+import { observer } from "mobx-react";
+import Measure from "react-measure";
+import { FieldWaiting, Opt } from "../../../fields/Field";
+import { Document } from "../../../fields/Document";
+import { KeyStore } from "../../../fields/KeyStore";
+import { CurrentUserUtils } from "../../../server/authentication/models/current_user_utils";
+import { ChartType, VisualBinRange } from '../../northstar/model/binRanges/VisualBinRange';
+import { VisualBinRangeHelper } from "../../northstar/model/binRanges/VisualBinRangeHelper";
+import { AggregateBinRange, AggregateFunction, BinRange, Catalog, DoubleValueAggregateResult, HistogramResult, Result } from "../../northstar/model/idea/idea";
+import { ModelHelpers } from "../../northstar/model/ModelHelpers";
+import { HistogramOperation } from "../../northstar/operations/HistogramOperation";
+import { SizeConverter } from "../../northstar/utils/SizeConverter";
+import { DragManager } from "../../util/DragManager";
+import { FieldView, FieldViewProps } from "../../views/nodes/FieldView";
+import { AttributeTransformationModel } from "../core/attribute/AttributeTransformationModel";
+import { HistogramField } from "../dash-fields/HistogramField";
+import "../utils/Extensions";
+import "./HistogramBox.scss";
+import { HistogramBoxPrimitives } from './HistogramBoxPrimitives';
+import { HistogramLabelPrimitives } from "./HistogramLabelPrimitives";
+import { StyleConstants } from "../utils/StyleContants";
+
+
+@observer
+export class HistogramBox extends React.Component<FieldViewProps> {
+    public static LayoutString(fieldStr: string = "DataKey") { return FieldView.LayoutString(HistogramBox, fieldStr) }
+    private _dropXRef = React.createRef<HTMLDivElement>();
+    private _dropYRef = React.createRef<HTMLDivElement>();
+    private _dropXDisposer?: DragManager.DragDropDisposer;
+    private _dropYDisposer?: DragManager.DragDropDisposer;
+
+    @observable public PanelWidth: number = 100;
+    @observable public PanelHeight: number = 100;
+    @observable public HistoOp: HistogramOperation = HistogramOperation.Empty;
+    @observable public VisualBinRanges: VisualBinRange[] = [];
+    @observable public ValueRange: number[] = [];
+    @computed public get HistogramResult(): HistogramResult { return this.HistoOp.Result as HistogramResult; }
+    @observable public SizeConverter: SizeConverter = new SizeConverter();
+
+    @computed get createOperationParamsCache() { trace(); return this.HistoOp.CreateOperationParameters(); }
+    @computed get BinRanges() { return this.HistogramResult ? this.HistogramResult.binRanges : undefined; }
+    @computed get ChartType() {
+        return !this.BinRanges ? ChartType.SinglePoint : this.BinRanges[0] instanceof AggregateBinRange ?
+            (this.BinRanges[1] instanceof AggregateBinRange ? ChartType.SinglePoint : ChartType.HorizontalBar) :
+            this.BinRanges[1] instanceof AggregateBinRange ? ChartType.VerticalBar : ChartType.HeatMap;
+    }
+
+    constructor(props: FieldViewProps) {
+        super(props);
+    }
+
+    @action
+    dropX = (e: Event, de: DragManager.DropEvent) => {
+        if (de.data instanceof DragManager.DocumentDragData) {
+            let h = de.data.draggedDocuments[0].GetT(KeyStore.Data, HistogramField);
+            if (h && h != FieldWaiting) {
+                this.HistoOp.X = h.Data.X;
+            }
+            e.stopPropagation();
+            e.preventDefault();
+        }
+    }
+    @action
+    dropY = (e: Event, de: DragManager.DropEvent) => {
+        if (de.data instanceof DragManager.DocumentDragData) {
+            let h = de.data.draggedDocuments[0].GetT(KeyStore.Data, HistogramField);
+            if (h && h != FieldWaiting) {
+                this.HistoOp.Y = h.Data.X;
+            }
+            e.stopPropagation();
+            e.preventDefault();
+        }
+    }
+
+    @action
+    xLabelPointerDown = (e: React.PointerEvent) => {
+        this.HistoOp.X = new AttributeTransformationModel(this.HistoOp.X.AttributeModel, this.HistoOp.X.AggregateFunction == AggregateFunction.None ? AggregateFunction.Count : AggregateFunction.None);
+    }
+    @action
+    yLabelPointerDown = (e: React.PointerEvent) => {
+        this.HistoOp.Y = new AttributeTransformationModel(this.HistoOp.Y.AttributeModel, this.HistoOp.Y.AggregateFunction == AggregateFunction.None ? AggregateFunction.Count : AggregateFunction.None);
+    }
+
+    componentDidMount() {
+        if (this._dropXRef.current) {
+            this._dropXDisposer = DragManager.MakeDropTarget(this._dropXRef.current, { handlers: { drop: this.dropX.bind(this) } });
+        }
+        if (this._dropYRef.current) {
+            this._dropYDisposer = DragManager.MakeDropTarget(this._dropYRef.current, { handlers: { drop: this.dropY.bind(this) } });
+        }
+        reaction(() => CurrentUserUtils.NorthstarDBCatalog, (catalog?: Catalog) => this.activateHistogramOperation(catalog), { fireImmediately: true });
+        reaction(() => [this.VisualBinRanges && this.VisualBinRanges.slice()], () => this.SizeConverter.SetVisualBinRanges(this.VisualBinRanges));
+        reaction(() => [this.PanelHeight, this.PanelWidth], () => this.SizeConverter.SetIsSmall(this.PanelWidth < 40 && this.PanelHeight < 40))
+        reaction(() => this.HistogramResult ? this.HistogramResult.binRanges : undefined,
+            (binRanges: BinRange[] | undefined) => {
+                if (binRanges) {
+                    this.VisualBinRanges.splice(0, this.VisualBinRanges.length, ...binRanges.map((br, ind) =>
+                        VisualBinRangeHelper.GetVisualBinRange(this.HistoOp.Schema!.distinctAttributeParameters, br, this.HistogramResult!, ind ? this.HistoOp.Y : this.HistoOp.X, this.ChartType)));
+
+                    let valueAggregateKey = ModelHelpers.CreateAggregateKey(this.HistoOp.Schema!.distinctAttributeParameters, this.HistoOp.V, this.HistogramResult!, ModelHelpers.AllBrushIndex(this.HistogramResult!));
+                    this.ValueRange = Object.values(this.HistogramResult!.bins!).reduce((prev, cur) => {
+                        let value = ModelHelpers.GetAggregateResult(cur, valueAggregateKey) as DoubleValueAggregateResult;
+                        return value && value.hasResult ? [Math.min(prev[0], value.result!), Math.max(prev[1], value.result!)] : prev;
+                    }, [Number.MAX_VALUE, Number.MIN_VALUE]);
+                }
+            });
+    }
+
+    componentWillUnmount() {
+        if (this._dropXDisposer)
+            this._dropXDisposer();
+        if (this._dropYDisposer)
+            this._dropYDisposer();
+    }
+
+    activateHistogramOperation(catalog?: Catalog) {
+        if (catalog) {
+            this.props.doc.GetTAsync(this.props.fieldKey, HistogramField).then((histoOp: Opt<HistogramField>) => runInAction(() => {
+                this.HistoOp = histoOp ? histoOp.Data : HistogramOperation.Empty;
+                if (this.HistoOp != HistogramOperation.Empty) {
+                    reaction(() => this.props.doc.GetList(KeyStore.LinkedFromDocs, []), (docs: Document[]) => this.HistoOp.Links.splice(0, this.HistoOp.Links.length, ...docs), { fireImmediately: true });
+                    reaction(() => this.props.doc.GetList(KeyStore.BrushingDocs, []).length,
+                        () => {
+                            let brushingDocs = this.props.doc.GetList(KeyStore.BrushingDocs, [] as Document[]);
+                            let proto = this.props.doc.GetPrototype() as Document;
+                            this.HistoOp.BrushLinks.splice(0, this.HistoOp.BrushLinks.length, ...brushingDocs.map((brush, i) => {
+                                brush.SetNumber(KeyStore.BackgroundColor, StyleConstants.BRUSH_COLORS[i % StyleConstants.BRUSH_COLORS.length]);
+                                let brushed = brush.GetList(KeyStore.BrushingDocs, [] as Document[]);
+                                return { l: brush, b: brushed[0].Id == proto.Id ? brushed[1] : brushed[0] }
+                            }));
+                        }, { fireImmediately: true });
+                    reaction(() => this.createOperationParamsCache, () => this.HistoOp.Update(), { fireImmediately: true });
+                }
+            }));
+        }
+    }
+    render() {
+        let labelY = this.HistoOp && this.HistoOp.Y ? this.HistoOp.Y.PresentedName : "<...>";
+        let labelX = this.HistoOp && this.HistoOp.X ? this.HistoOp.X.PresentedName : "<...>";
+        var h = this.props.isTopMost ? this.PanelHeight : this.props.doc.GetNumber(KeyStore.Height, 0);
+        var w = this.props.isTopMost ? this.PanelWidth : this.props.doc.GetNumber(KeyStore.Width, 0);
+        let loff = this.SizeConverter.LeftOffset;
+        let toff = this.SizeConverter.TopOffset;
+        let roff = this.SizeConverter.RightOffset;
+        let boff = this.SizeConverter.BottomOffset;
+        return (
+            <Measure onResize={(r: any) => runInAction(() => { this.PanelWidth = r.entry.width; this.PanelHeight = r.entry.height })}>
+                {({ measureRef }) =>
+                    <div className="histogrambox-container" ref={measureRef} style={{ transform: `translate(${-w / 2}px, ${-h / 2}px)` }}>
+                        <div className="histogrambox-yaxislabel" onPointerDown={this.yLabelPointerDown} ref={this._dropYRef} >
+                            <span className="histogrambox-yaxislabel-text">
+                                {labelY}
+                            </span>
+                        </div>
+                        <div className="histogrambox-primitives" style={{
+                            transform: `translate(${loff + 25}px, ${toff}px)`,
+                            width: `calc(100% - ${loff + roff + 25}px)`,
+                            height: `calc(100% - ${toff + boff}px)`,
+                        }}>
+                            <HistogramLabelPrimitives HistoBox={this} />
+                            <HistogramBoxPrimitives HistoBox={this} />
+                        </div>
+                        <div className="histogrambox-xaxislabel" onPointerDown={this.xLabelPointerDown} ref={this._dropXRef} >
+                            {labelX}
+                        </div>
+                    </div>
+                }
+            </Measure>
+        )
+    }
+}
+
diff --git a/src/client/northstar/dash-nodes/HistogramBoxPrimitives.scss b/src/client/northstar/dash-nodes/HistogramBoxPrimitives.scss
new file mode 100644
index 000000000..ce9edd65e
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramBoxPrimitives.scss
@@ -0,0 +1,30 @@
+.histogramboxprimitives-container {
+    width: 100%;
+    height: 100%;
+}
+.histogramboxprimitives-border {
+    border: 3px;
+    border-style: solid;
+    border-color: white;
+    pointer-events: none;
+    position: absolute;
+}
+.histogramboxprimitives-bar {
+    position: absolute;
+    border: 1px;
+    border-style: solid;
+    border-color: #282828;
+    pointer-events: all;
+}
+
+.histogramboxprimitives-placer {
+    position: absolute;
+    pointer-events: none;
+    width: 100%;
+    height: 100%;
+}
+.histogramboxprimitives-line {
+    position: absolute;
+    background: darkGray;
+    opacity: 0.4;
+}
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramBoxPrimitives.tsx b/src/client/northstar/dash-nodes/HistogramBoxPrimitives.tsx
new file mode 100644
index 000000000..e9adb3ce5
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramBoxPrimitives.tsx
@@ -0,0 +1,124 @@
+import React = require("react")
+import { computed, observable, reaction, runInAction, trace } from "mobx";
+import { observer } from "mobx-react";
+import { Utils as DashUtils } from '../../../Utils';
+import { FilterModel } from "../../northstar/core/filter/FilterModel";
+import { ModelHelpers } from "../../northstar/model/ModelHelpers";
+import { ArrayUtil } from "../../northstar/utils/ArrayUtil";
+import { LABColor } from '../../northstar/utils/LABcolor';
+import { PIXIRectangle } from "../../northstar/utils/MathUtil";
+import { StyleConstants } from "../../northstar/utils/StyleContants";
+import { HistogramBinPrimitiveCollection, HistogramBinPrimitive } from "./HistogramBinPrimitiveCollection";
+import { HistogramBox } from "./HistogramBox";
+import "./HistogramBoxPrimitives.scss";
+
+export interface HistogramPrimitivesProps {
+    HistoBox: HistogramBox;
+}
+@observer
+export class HistogramBoxPrimitives extends React.Component<HistogramPrimitivesProps> {
+    private get histoOp() { return this.props.HistoBox.HistoOp; }
+    private get renderDimension() { return this.props.HistoBox.SizeConverter.RenderDimension; }
+    @observable _selectedPrims: HistogramBinPrimitive[] = [];
+    @computed get xaxislines() { return this.renderGridLinesAndLabels(0); }
+    @computed get yaxislines() { return this.renderGridLinesAndLabels(1); }
+    @computed get selectedPrimitives() { return this._selectedPrims.map(bp => this.drawRect(bp.Rect, bp.BarAxis, undefined, "border")); }
+    @computed get binPrimitives() {
+        let histoResult = this.props.HistoBox.HistogramResult;
+        if (!histoResult || !histoResult.bins || !this.props.HistoBox.VisualBinRanges.length)
+            return (null);
+        trace();
+        let allBrushIndex = ModelHelpers.AllBrushIndex(histoResult);
+        return Object.keys(histoResult.bins).reduce((prims, key) => {
+            let drawPrims = new HistogramBinPrimitiveCollection(histoResult!.bins![key], this.props.HistoBox);
+            let toggle = this.getSelectionToggle(drawPrims.BinPrimitives, allBrushIndex,
+                ModelHelpers.GetBinFilterModel(histoResult!.bins![key], allBrushIndex, histoResult!, this.histoOp.X, this.histoOp.Y));
+            drawPrims.BinPrimitives.filter(bp => bp.DataValue && bp.BrushIndex !== allBrushIndex).map(bp =>
+                prims.push(...[{ r: bp.Rect, c: bp.Color }, { r: bp.MarginRect, c: StyleConstants.MARGIN_BARS_COLOR }].map(pair => this.drawRect(pair.r, bp.BarAxis, pair.c, "bar", toggle))));
+            return prims;
+        }, [] as JSX.Element[]);
+    }
+
+    componentDidMount() {
+        reaction(() => this.props.HistoBox.HistoOp.FilterString, () => this._selectedPrims.length = this.histoOp.FilterModels.length = 0);
+    }
+
+    private getSelectionToggle(binPrimitives: HistogramBinPrimitive[], allBrushIndex: number, filterModel: FilterModel) {
+        let allBrushPrim = ArrayUtil.FirstOrDefault(binPrimitives, bp => bp.BrushIndex == allBrushIndex);
+        return !allBrushPrim ? () => { } : () => runInAction(() => {
+            if (ArrayUtil.Contains(this.histoOp.FilterModels, filterModel)) {
+                this._selectedPrims.splice(this._selectedPrims.indexOf(allBrushPrim!), 1);
+                this.histoOp.RemoveFilterModels([filterModel]);
+            }
+            else {
+                this._selectedPrims.push(allBrushPrim!);
+                this.histoOp.AddFilterModels([filterModel]);
+            }
+        })
+    }
+
+    private renderGridLinesAndLabels(axis: number) {
+        if (!this.props.HistoBox.SizeConverter.Initialized)
+            return (null);
+        let labels = this.props.HistoBox.VisualBinRanges[axis].GetLabels();
+        return labels.reduce((prims, binLabel, i) => {
+            let r = this.props.HistoBox.SizeConverter.DataToScreenRange(binLabel.minValue!, binLabel.maxValue!, axis);
+            prims.push(this.drawLine(r.xFrom, r.yFrom, axis == 0 ? 0 : r.xTo - r.xFrom, axis == 0 ? r.yTo - r.yFrom : 0));
+            if (i == labels.length - 1)
+                prims.push(this.drawLine(axis == 0 ? r.xTo : r.xFrom, axis == 0 ? r.yFrom : r.yTo, axis == 0 ? 0 : r.xTo - r.xFrom, axis == 0 ? r.yTo - r.yFrom : 0));
+            return prims;
+        }, [] as JSX.Element[]);
+    }
+
+    drawEntity(xFrom: number, yFrom: number, entity: JSX.Element) {
+        let transXpercent = xFrom / this.renderDimension * 100;
+        let transYpercent = yFrom / this.renderDimension * 100;
+        return (<div key={DashUtils.GenerateGuid()} className={`histogramboxprimitives-placer`} style={{ transform: `translate(${transXpercent}%, ${transYpercent}%)` }}>
+            {entity}
+        </div>);
+    }
+    drawLine(xFrom: number, yFrom: number, width: number, height: number) {
+        if (height < 0) {
+            yFrom += height;
+            height = -height;
+        }
+        if (width < 0) {
+            xFrom += width;
+            width = -width;
+        }
+        let trans2Xpercent = width == 0 ? `1px` : `${(xFrom + width) / this.renderDimension * 100}%`;
+        let trans2Ypercent = height == 0 ? `1px` : `${(yFrom + height) / this.renderDimension * 100}%`;
+        let line = (<div className="histogramboxprimitives-line" style={{ width: trans2Xpercent, height: trans2Ypercent, }} />);
+        return this.drawEntity(xFrom, yFrom, line);
+    }
+    drawRect(r: PIXIRectangle, barAxis: number, color: number | undefined, classExt: string, tapHandler: () => void = () => { }) {
+        if (r.height < 0) {
+            r.y += r.height;
+            r.height = -r.height;
+        }
+        if (r.width < 0) {
+            r.x += r.width;
+            r.width = -r.width;
+        }
+        let widthPercent = r.width / this.renderDimension * 100;
+        let heightPercent = r.height / this.renderDimension * 100;
+        let rect = (<div className={`histogramboxprimitives-${classExt}`} onPointerDown={(e: React.PointerEvent) => { if (e.button == 0) tapHandler() }}
+            style={{
+                borderBottomStyle: barAxis == 1 ? "none" : "solid",
+                borderLeftStyle: barAxis == 0 ? "none" : "solid",
+                width: `${widthPercent}%`,
+                height: `${heightPercent}%`,
+                background: color ? `${LABColor.RGBtoHexString(color)}` : ""
+            }}
+        />);
+        return this.drawEntity(r.x, r.y, rect);
+    }
+    render() {
+        return <div className="histogramboxprimitives-container">
+            {this.xaxislines}
+            {this.yaxislines}
+            {this.binPrimitives}
+            {this.selectedPrimitives}
+        </div>
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramLabelPrimitives.scss b/src/client/northstar/dash-nodes/HistogramLabelPrimitives.scss
new file mode 100644
index 000000000..304d33771
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramLabelPrimitives.scss
@@ -0,0 +1,13 @@
+
+  .histogramLabelPrimitives-gridlabel {
+    position:absolute;
+    transform-origin: left top;
+    font-size: 11;
+    color:white;
+  }
+  .histogramLabelPrimitives-placer {
+    position:absolute;
+    width:100%;
+    height:100%;
+    pointer-events: none;
+  }
\ No newline at end of file
diff --git a/src/client/northstar/dash-nodes/HistogramLabelPrimitives.tsx b/src/client/northstar/dash-nodes/HistogramLabelPrimitives.tsx
new file mode 100644
index 000000000..93b237deb
--- /dev/null
+++ b/src/client/northstar/dash-nodes/HistogramLabelPrimitives.tsx
@@ -0,0 +1,79 @@
+import React = require("react")
+import { action, computed, reaction } from "mobx";
+import { observer } from "mobx-react";
+import { Utils as DashUtils } from '../../../Utils';
+import { NominalVisualBinRange } from "../model/binRanges/NominalVisualBinRange";
+import "../utils/Extensions";
+import { StyleConstants } from "../utils/StyleContants";
+import { HistogramBox } from "./HistogramBox";
+import "./HistogramLabelPrimitives.scss";
+import { HistogramPrimitivesProps } from "./HistogramBoxPrimitives";
+
+@observer
+export class HistogramLabelPrimitives extends React.Component<HistogramPrimitivesProps> {
+    componentDidMount() {
+        reaction(() => [this.props.HistoBox.PanelWidth, this.props.HistoBox.SizeConverter.LeftOffset, this.props.HistoBox.VisualBinRanges.length],
+            (fields) => HistogramLabelPrimitives.computeLabelAngle(fields[0] as number, fields[1] as number, this.props.HistoBox), { fireImmediately: true });
+    }
+
+    @action
+    static computeLabelAngle(panelWidth: number, leftOffset: number, histoBox: HistogramBox) {
+        const textWidth = 30;
+        if (panelWidth > 0 && histoBox.VisualBinRanges.length && histoBox.VisualBinRanges[0] instanceof NominalVisualBinRange) {
+            let space = (panelWidth - leftOffset * 2) / histoBox.VisualBinRanges[0].GetBins().length;
+            histoBox.SizeConverter.SetLabelAngle(Math.min(Math.PI / 2, Math.max(Math.PI / 6, textWidth / space * Math.PI / 2)));
+        } else if (histoBox.SizeConverter.LabelAngle) {
+            histoBox.SizeConverter.SetLabelAngle(0);
+        }
+    }
+    @computed get xaxislines() { return this.renderGridLinesAndLabels(0); }
+    @computed get yaxislines() { return this.renderGridLinesAndLabels(1); }
+
+    private renderGridLinesAndLabels(axis: number) {
+        let sc = this.props.HistoBox.SizeConverter;
+        let vb = this.props.HistoBox.VisualBinRanges;
+        if (!vb.length || !sc.Initialized)
+            return (null);
+        let dim = (axis == 0 ? this.props.HistoBox.PanelWidth : this.props.HistoBox.PanelHeight) / ((axis == 0 && vb[axis] instanceof NominalVisualBinRange) ?
+            (12 + 5) : //  (<number>FontStyles.AxisLabel.fontSize + 5)));
+            sc.MaxLabelSizes[axis].coords[axis] + 5);
+
+        let labels = vb[axis].GetLabels();
+        return labels.reduce((prims, binLabel, i) => {
+            let r = sc.DataToScreenRange(binLabel.minValue!, binLabel.maxValue!, axis);
+            if (i % Math.ceil(labels.length / dim) === 0 && binLabel.label) {
+                const label = binLabel.label.Truncate(StyleConstants.MAX_CHAR_FOR_HISTOGRAM_LABELS, "...");
+                const textHeight = 14; const textWidth = 30;
+                let xStart = (axis === 0 ? r.xFrom + (r.xTo - r.xFrom) / 2.0 : r.xFrom - 10 - textWidth);
+                let yStart = (axis === 1 ? r.yFrom - textHeight / 2 : r.yFrom);
+
+                if (axis == 0 && vb[axis] instanceof NominalVisualBinRange) {
+                    let space = (r.xTo - r.xFrom) / sc.RenderDimension * this.props.HistoBox.PanelWidth;
+                    xStart += Math.max(textWidth / 2, (1 - textWidth / space) * textWidth / 2) - textHeight / 2;
+                }
+
+                let xPercent = axis == 1 ? `${xStart}px` : `${xStart / sc.RenderDimension * 100}%`
+                let yPercent = axis == 0 ? `${this.props.HistoBox.PanelHeight - sc.BottomOffset - textHeight}px` : `${yStart / sc.RenderDimension * 100}%`
+
+                prims.push(
+                    <div className="histogramLabelPrimitives-placer" key={DashUtils.GenerateGuid()} style={{ transform: `translate(${xPercent}, ${yPercent})` }}>
+                        <div className="histogramLabelPrimitives-gridlabel" style={{ transform: `rotate(${axis == 0 ? sc.LabelAngle : 0}rad)` }}>
+                            {label}
+                        </div>
+                    </div>
+                )
+            }
+            return prims;
+        }, [] as JSX.Element[]);
+    }
+
+    render() {
+        let xaxislines = this.xaxislines;
+        let yaxislines = this.yaxislines;
+        return <div className="histogramLabelPrimitives-container">
+            {xaxislines}
+            {yaxislines}
+        </div>
+    }
+
+}
\ No newline at end of file
diff --git a/src/client/northstar/manager/Gateway.ts b/src/client/northstar/manager/Gateway.ts
new file mode 100644
index 000000000..5ae5e4f47
--- /dev/null
+++ b/src/client/northstar/manager/Gateway.ts
@@ -0,0 +1,269 @@
+import { Catalog, OperationReference, Result, CompileResults } from "../model/idea/idea"
+import { computed, observable, action } from "mobx";
+
+export class Gateway {
+
+    private static _instance: Gateway;
+
+    private constructor() {
+    }
+
+    public static get Instance() {
+        return this._instance || (this._instance = new this());
+    }
+
+    public async GetCatalog(): Promise<Catalog> {
+        try {
+            const json = await this.MakeGetRequest("catalog");
+            const cat = Catalog.fromJS(json);
+            return cat;
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+    public async ClearCatalog(): Promise<void> {
+        try {
+            const json = await this.MakePostJsonRequest("Datamart/ClearAllAugmentations", {});
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+    public async TerminateServer(): Promise<void> {
+        try {
+            const url = Gateway.ConstructUrl("terminateServer");
+            const response = await fetch(url,
+                {
+                    redirect: "follow",
+                    method: "POST",
+                    credentials: "include"
+                });
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+    public async Compile(data: any): Promise<CompileResults | undefined> {
+        const json = await this.MakePostJsonRequest("compile", data);
+        if (json != null) {
+            const cr = CompileResults.fromJS(json);
+            return cr;
+        }
+    }
+
+    public async SubmitResult(data: any): Promise<void> {
+        try {
+            console.log(data);
+            const url = Gateway.ConstructUrl("submitProblem");
+            const response = await fetch(url,
+                {
+                    redirect: "follow",
+                    method: "POST",
+                    credentials: "include",
+                    body: JSON.stringify(data)
+                });
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+    public async SpecifyProblem(data: any): Promise<void> {
+        try {
+            console.log(data);
+            const url = Gateway.ConstructUrl("specifyProblem");
+            const response = await fetch(url,
+                {
+                    redirect: "follow",
+                    method: "POST",
+                    credentials: "include",
+                    body: JSON.stringify(data)
+                });
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+    public async ExportToScript(solutionId: string): Promise<string> {
+        try {
+            const url = Gateway.ConstructUrl("exportsolution/script/" + solutionId);
+            const response = await fetch(url,
+                {
+                    redirect: "follow",
+                    method: "GET",
+                    credentials: "include"
+                });
+            return await response.text();
+        }
+        catch (error) {
+            throw new Error("can not reach northstar's backend");
+        }
+    }
+
+
+    public async StartOperation(data: any): Promise<OperationReference | undefined> {
+        const json = await this.MakePostJsonRequest("operation", data);
+        if (json != null) {
+            const or = OperationReference.fromJS(json);
+            return or;
+        }
+    }
+
+    public async GetResult(data: any): Promise<Result | undefined> {
+        const json = await this.MakePostJsonRequest("result", data);
+        if (json != null) {
+            const res = Result.fromJS(json);
+            return res;
+        }
+    }
+
+    public async PauseOperation(data: any): Promise<void> {
+        const url = Gateway.ConstructUrl("pause");
+        await fetch(url,
+            {
+                redirect: "follow",
+                method: "POST",
+                credentials: "include",
+                body: JSON.stringify(data)
+            });
+    }
+
+    public async MakeGetRequest(endpoint: string, signal?: AbortSignal): Promise<any> {
+        const url = Gateway.ConstructUrl(endpoint);
+        const response = await fetch(url,
+            {
+                redirect: "follow",
+                method: "GET",
+                credentials: "include",
+                signal
+            });
+        const json = await response.json();
+        return json;
+    }
+
+    public async MakePostJsonRequest(endpoint: string, data: any, signal?: AbortSignal): Promise<any> {
+        const url = Gateway.ConstructUrl(endpoint);
+        const response = await fetch(url,
+            {
+                redirect: "follow",
+                method: "POST",
+                credentials: "include",
+                body: JSON.stringify(data),
+                signal
+            });
+        const json = await response.json();
+        return json;
+    }
+
+
+    public static ConstructUrl(appendix: string): string {
+        let base = Settings.Instance.ServerUrl;
+        if (base.slice(-1) == "/") {
+            base = base.slice(0, -1);
+        }
+        let url = base + "/" + Settings.Instance.ServerApiPath + "/" + appendix;
+        return url;
+    }
+}
+
+declare var ENV: any;
+
+export class Settings {
+    private _environment: any;
+
+    @observable
+    public ServerUrl: string = document.URL;
+
+    @observable
+    public ServerApiPath?: string;
+
+    @observable
+    public SampleSize?: number;
+
+    @observable
+    public XBins?: number;
+
+    @observable
+    public YBins?: number;
+
+    @observable
+    public SplashTimeInMS?: number;
+
+    @observable
+    public ShowFpsCounter?: boolean;
+
+    @observable
+    public IsMenuFixed?: boolean;
+
+    @observable
+    public ShowShutdownButton?: boolean;
+
+    @observable
+    public IsDarpa?: boolean;
+
+    @observable
+    public IsIGT?: boolean;
+
+    @observable
+    public DegreeOfParallelism?: number;
+
+    @observable
+    public ShowWarnings?: boolean;
+
+    @computed
+    public get IsDev(): boolean {
+        return ENV.IsDev;
+    }
+
+    @computed
+    public get TestDataFolderPath(): string {
+        return this.Origin + "testdata/";
+    }
+
+    @computed
+    public get Origin(): string {
+        return window.location.origin + "/";
+    }
+
+    private static _instance: Settings;
+
+    @action
+    public Update(environment: any): void {
+        /*let serverParam = new URL(document.URL).searchParams.get("serverUrl");
+        if (serverParam) {
+            if (serverParam === "debug") {
+                this.ServerUrl = `http://${window.location.hostname}:1234`;
+            }
+            else {
+                this.ServerUrl = serverParam;
+            }
+        }
+        else {
+            this.ServerUrl = environment["SERVER_URL"] ? environment["SERVER_URL"] : document.URL;
+        }*/
+        this.ServerUrl = environment["SERVER_URL"] ? environment["SERVER_URL"] : document.URL;
+        this.ServerApiPath = environment["SERVER_API_PATH"];
+        this.SampleSize = environment["SAMPLE_SIZE"];
+        this.XBins = environment["X_BINS"];
+        this.YBins = environment["Y_BINS"];
+        this.SplashTimeInMS = environment["SPLASH_TIME_IN_MS"];
+        this.ShowFpsCounter = environment["SHOW_FPS_COUNTER"];
+        this.ShowShutdownButton = environment["SHOW_SHUTDOWN_BUTTON"];
+        this.IsMenuFixed = environment["IS_MENU_FIXED"];
+        this.IsDarpa = environment["IS_DARPA"];
+        this.IsIGT = environment["IS_IGT"];
+        this.DegreeOfParallelism = environment["DEGREE_OF_PARALLISM"];
+    }
+
+    public static get Instance(): Settings {
+        if (!this._instance) {
+            this._instance = new Settings();
+        }
+        return this._instance;
+    }
+}
diff --git a/src/client/northstar/model/ModelExtensions.ts b/src/client/northstar/model/ModelExtensions.ts
new file mode 100644
index 000000000..9fcba7f1c
--- /dev/null
+++ b/src/client/northstar/model/ModelExtensions.ts
@@ -0,0 +1,48 @@
+import { AttributeParameters, Brush, MarginAggregateParameters, SingleDimensionAggregateParameters, Solution } from '../model/idea/idea'
+import { Utils } from '../utils/Utils'
+
+import { FilterModel } from '../core/filter/FilterModel'
+
+(SingleDimensionAggregateParameters as any).prototype["Equals"] = function (other: Object) {
+    if (!Utils.EqualityHelper(this, other)) return false;
+    if (!Utils.EqualityHelper((this as SingleDimensionAggregateParameters).attributeParameters!,
+        (other as SingleDimensionAggregateParameters).attributeParameters!)) return false;
+    if (!((this as SingleDimensionAggregateParameters).attributeParameters! as any)["Equals"]((other as SingleDimensionAggregateParameters).attributeParameters)) return false;
+    return true;
+}
+
+{
+    (AttributeParameters as any).prototype["Equals"] = function (other: AttributeParameters) {
+        return (<any>this).constructor.name === (<any>other).constructor.name &&
+            this.rawName === other.rawName;
+    }
+}
+
+{
+    (Solution as any).prototype["Equals"] = function (other: Object) {
+        if (!Utils.EqualityHelper(this, other)) return false;
+        if ((this as Solution).solutionId !== (other as Solution).solutionId) return false;
+        return true;
+    }
+}
+
+{
+    (MarginAggregateParameters as any).prototype["Equals"] = function (other: Object) {
+        if (!Utils.EqualityHelper(this, other)) return false;
+        if (!Utils.EqualityHelper((this as SingleDimensionAggregateParameters).attributeParameters!,
+            (other as SingleDimensionAggregateParameters).attributeParameters!)) return false;
+        if (!((this as SingleDimensionAggregateParameters).attributeParameters! as any)["Equals"]((other as SingleDimensionAggregateParameters).attributeParameters!)) return false;
+
+        if ((this as MarginAggregateParameters).aggregateFunction !== (other as MarginAggregateParameters).aggregateFunction) return false;
+        return true;
+    }
+}
+
+{
+    (Brush as any).prototype["Equals"] = function (other: Object) {
+        if (!Utils.EqualityHelper(this, other)) return false;
+        if ((this as Brush).brushEnum !== (other as Brush).brushEnum) return false;
+        if ((this as Brush).brushIndex !== (other as Brush).brushIndex) return false;
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/ModelHelpers.ts b/src/client/northstar/model/ModelHelpers.ts
new file mode 100644
index 000000000..d0711fb69
--- /dev/null
+++ b/src/client/northstar/model/ModelHelpers.ts
@@ -0,0 +1,215 @@
+
+import { action } from "mobx";
+import { AggregateFunction, AggregateKey, AggregateParameters, AttributeColumnParameters, AttributeParameters, AverageAggregateParameters, Bin, BinningParameters, Brush, BrushEnum, CountAggregateParameters, DataType, EquiWidthBinningParameters, HistogramResult, MarginAggregateParameters, SingleBinBinningParameters, SingleDimensionAggregateParameters, SumAggregateParameters, AggregateBinRange, NominalBinRange, AlphabeticBinRange, Predicate, Schema, Attribute, AttributeGroup, Exception, AttributeBackendParameters, AttributeCodeParameters } from '../model/idea/idea';
+import { ValueComparison } from "../core/filter/ValueComparision";
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { AttributeModel, ColumnAttributeModel, BackendAttributeModel, CodeAttributeModel } from "../core/attribute/AttributeModel";
+import { FilterModel } from "../core/filter/FilterModel";
+import { AlphabeticVisualBinRange } from "./binRanges/AlphabeticVisualBinRange";
+import { NominalVisualBinRange } from "./binRanges/NominalVisualBinRange";
+import { VisualBinRangeHelper } from "./binRanges/VisualBinRangeHelper";
+import { AttributeTransformationModel } from "../core/attribute/AttributeTransformationModel";
+import { CurrentUserUtils } from "../../../server/authentication/models/current_user_utils";
+
+export class ModelHelpers {
+
+    public static CreateAggregateKey(distinctAttributeParameters: AttributeParameters | undefined, atm: AttributeTransformationModel, histogramResult: HistogramResult,
+        brushIndex: number, aggParameters?: SingleDimensionAggregateParameters): AggregateKey {
+        {
+            if (aggParameters == undefined) {
+                aggParameters = ModelHelpers.GetAggregateParameter(distinctAttributeParameters, atm);
+            }
+            else {
+                aggParameters.attributeParameters = ModelHelpers.GetAttributeParameters(atm.AttributeModel);
+            }
+            return new AggregateKey(
+                {
+                    aggregateParameterIndex: ModelHelpers.GetAggregateParametersIndex(histogramResult, aggParameters),
+                    brushIndex: brushIndex
+                });
+        }
+    }
+
+    public static GetAggregateParametersIndex(histogramResult: HistogramResult, aggParameters?: AggregateParameters): number {
+        return ArrayUtil.IndexOfWithEqual(histogramResult.aggregateParameters!, aggParameters);
+    }
+
+    public static GetAggregateParameter(distinctAttributeParameters: AttributeParameters | undefined, atm: AttributeTransformationModel): AggregateParameters | undefined {
+        var aggParam: AggregateParameters | undefined;
+        if (atm.AggregateFunction === AggregateFunction.Avg) {
+            var avg = new AverageAggregateParameters();
+            avg.attributeParameters = ModelHelpers.GetAttributeParameters(atm.AttributeModel);
+            avg.distinctAttributeParameters = distinctAttributeParameters;
+            aggParam = avg;
+        }
+        else if (atm.AggregateFunction === AggregateFunction.Count) {
+            var cnt = new CountAggregateParameters();
+            cnt.attributeParameters = ModelHelpers.GetAttributeParameters(atm.AttributeModel);
+            cnt.distinctAttributeParameters = distinctAttributeParameters;
+            aggParam = cnt;
+        }
+        else if (atm.AggregateFunction === AggregateFunction.Sum) {
+            var sum = new SumAggregateParameters();
+            sum.attributeParameters = ModelHelpers.GetAttributeParameters(atm.AttributeModel);
+            sum.distinctAttributeParameters = distinctAttributeParameters;
+            aggParam = sum;
+        }
+        return aggParam;
+    }
+
+    public static GetAggregateParametersWithMargins(distinctAttributeParameters: AttributeParameters | undefined, atms: Array<AttributeTransformationModel>): Array<AggregateParameters> {
+        var aggregateParameters = new Array<AggregateParameters>();
+        atms.forEach(agg => {
+            var aggParams = ModelHelpers.GetAggregateParameter(distinctAttributeParameters, agg);
+            if (aggParams) {
+                aggregateParameters.push(aggParams);
+
+                var margin = new MarginAggregateParameters()
+                margin.aggregateFunction = agg.AggregateFunction;
+                margin.attributeParameters = ModelHelpers.GetAttributeParameters(agg.AttributeModel);
+                margin.distinctAttributeParameters = distinctAttributeParameters;
+                aggregateParameters.push(margin);
+            }
+        });
+
+        return aggregateParameters;
+    }
+
+    public static GetBinningParameters(attr: AttributeTransformationModel, nrOfBins: number, minvalue?: number, maxvalue?: number): BinningParameters {
+        if (attr.AggregateFunction === AggregateFunction.None) {
+            return new EquiWidthBinningParameters(
+                {
+                    attributeParameters: ModelHelpers.GetAttributeParameters(attr.AttributeModel),
+                    requestedNrOfBins: nrOfBins,
+                    minValue: minvalue,
+                    maxValue: maxvalue
+                });
+        }
+        else {
+            return new SingleBinBinningParameters(
+                {
+                    attributeParameters: ModelHelpers.GetAttributeParameters(attr.AttributeModel)
+                });
+        }
+    }
+
+    public static GetAttributeParametersFromAttributeModel(am: AttributeModel): AttributeParameters {
+        if (am instanceof ColumnAttributeModel) {
+            return new AttributeColumnParameters(
+                {
+                    rawName: am.CodeName,
+                    visualizationHints: am.VisualizationHints
+                });
+        }
+        else if (am instanceof BackendAttributeModel) {
+            return new AttributeBackendParameters(
+                {
+                    rawName: am.CodeName,
+                    visualizationHints: am.VisualizationHints,
+                    id: (am as BackendAttributeModel).Id
+                });
+        }
+        else if (am instanceof CodeAttributeModel) {
+            return new AttributeCodeParameters(
+                {
+                    rawName: am.CodeName,
+                    visualizationHints: am.VisualizationHints,
+                    code: (am as CodeAttributeModel).Code
+                });
+        }
+        else {
+            throw new Exception()
+        }
+    }
+
+    public static GetAttributeParameters(am: AttributeModel): AttributeParameters {
+        return this.GetAttributeParametersFromAttributeModel(am);
+    }
+
+    public static OverlapBrushIndex(histogramResult: HistogramResult): number {
+        var brush = ArrayUtil.First(histogramResult.brushes!, (b: any) => b.brushEnum === BrushEnum.Overlap);
+        return ModelHelpers.GetBrushIndex(histogramResult, brush);
+    }
+
+    public static AllBrushIndex(histogramResult: HistogramResult): number {
+        var brush = ArrayUtil.First(histogramResult.brushes!, (b: any) => b.brushEnum === BrushEnum.All);
+        return ModelHelpers.GetBrushIndex(histogramResult, brush);
+    }
+
+    public static RestBrushIndex(histogramResult: HistogramResult): number {
+        var brush = ArrayUtil.First(histogramResult.brushes!, (b: Brush) => b.brushEnum === BrushEnum.Rest);
+        return ModelHelpers.GetBrushIndex(histogramResult, brush);
+    }
+
+    public static GetBrushIndex(histogramResult: HistogramResult, brush: Brush): number {
+        return ArrayUtil.IndexOfWithEqual(histogramResult.brushes!, brush);
+    }
+
+    public static GetAggregateResult(bin: Bin, aggregateKey: AggregateKey) {
+        if (aggregateKey.aggregateParameterIndex == -1 || aggregateKey.brushIndex == -1) {
+            return null;
+        }
+        return bin.aggregateResults![aggregateKey.aggregateParameterIndex! * bin.ySize! + aggregateKey.brushIndex!];
+    }
+
+    @action
+    public static PossibleAggegationFunctions(atm: AttributeTransformationModel): Array<AggregateFunction> {
+        var ret = new Array<AggregateFunction>();
+        ret.push(AggregateFunction.None);
+        ret.push(AggregateFunction.Count);
+        if (atm.AttributeModel.DataType == DataType.Float ||
+            atm.AttributeModel.DataType == DataType.Double ||
+            atm.AttributeModel.DataType == DataType.Int) {
+            ret.push(AggregateFunction.Avg);
+            ret.push(AggregateFunction.Sum);
+        }
+        return ret;
+    }
+
+    public static GetBinFilterModel(
+        bin: Bin, brushIndex: number, histogramResult: HistogramResult,
+        xAom: AttributeTransformationModel, yAom: AttributeTransformationModel): FilterModel {
+        var dimensions: Array<AttributeTransformationModel> = [xAom, yAom];
+        var filterModel = new FilterModel();
+
+        for (var i = 0; i < histogramResult.binRanges!.length; i++) {
+            if (!(histogramResult.binRanges![i] instanceof AggregateBinRange)) {
+                var binRange = VisualBinRangeHelper.GetNonAggregateVisualBinRange(histogramResult.binRanges![i]);
+                var dataFrom = binRange.GetValueFromIndex(bin.binIndex!.indices![i]);
+                var dataTo = binRange.AddStep(dataFrom);
+
+                if (binRange instanceof NominalVisualBinRange) {
+                    var tt = binRange.GetLabel(dataFrom);
+                    filterModel.ValueComparisons.push(new ValueComparison(dimensions[i].AttributeModel, Predicate.EQUALS, tt));
+                }
+                else if (binRange instanceof AlphabeticVisualBinRange) {
+                    filterModel.ValueComparisons.push(new ValueComparison(dimensions[i].AttributeModel, Predicate.STARTS_WITH,
+                        binRange.GetLabel(dataFrom)));
+                }
+                else {
+                    filterModel.ValueComparisons.push(new ValueComparison(dimensions[i].AttributeModel, Predicate.GREATER_THAN_EQUAL, dataFrom));
+                    filterModel.ValueComparisons.push(new ValueComparison(dimensions[i].AttributeModel, Predicate.LESS_THAN, dataTo));
+                }
+            }
+        }
+
+        return filterModel;
+    }
+
+    public GetAllAttributes(schema: Schema) {
+        if (!schema || !schema.rootAttributeGroup) {
+            return [];
+        }
+        const recurs = (attrs: Attribute[], g: AttributeGroup) => {
+            if (g.attributes) {
+                attrs.push.apply(attrs, g.attributes);
+                if (g.attributeGroups) {
+                    g.attributeGroups.forEach(ng => recurs(attrs, ng));
+                }
+            }
+        };
+        const allAttributes: Attribute[] = new Array<Attribute>();
+        recurs(allAttributes, schema.rootAttributeGroup);
+        return allAttributes;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/AlphabeticVisualBinRange.ts b/src/client/northstar/model/binRanges/AlphabeticVisualBinRange.ts
new file mode 100644
index 000000000..995bf4e0b
--- /dev/null
+++ b/src/client/northstar/model/binRanges/AlphabeticVisualBinRange.ts
@@ -0,0 +1,52 @@
+import { AlphabeticBinRange, BinLabel } from '../../model/idea/idea'
+import { VisualBinRange } from './VisualBinRange'
+
+export class AlphabeticVisualBinRange extends VisualBinRange {
+    public DataBinRange: AlphabeticBinRange;
+
+    constructor(dataBinRange: AlphabeticBinRange) {
+        super();
+        this.DataBinRange = dataBinRange;
+    }
+
+    public AddStep(value: number): number {
+        return value + 1;
+    }
+
+    public GetValueFromIndex(index: number): number {
+        return index;
+    }
+
+    public GetBins(): number[] {
+        var bins = new Array<number>();
+        var idx = 0;
+        for (var key in this.DataBinRange.labelsValue) {
+            if (this.DataBinRange.labelsValue.hasOwnProperty(key)) {
+                bins.push(idx);
+                idx++;
+            }
+        }
+        return bins;
+    }
+
+    public GetLabel(value: number): string {
+        return this.DataBinRange.prefix + this.DataBinRange.valuesLabel![value];
+    }
+
+    public GetLabels(): Array<BinLabel> {
+        var labels = new Array<BinLabel>();
+        var count = 0;
+        for (var key in this.DataBinRange.valuesLabel) {
+            if (this.DataBinRange.valuesLabel.hasOwnProperty(key)) {
+                var value = this.DataBinRange.valuesLabel[key];
+                labels.push(new BinLabel({
+                    value: parseFloat(key),
+                    minValue: count++,
+                    maxValue: count,
+                    label: this.DataBinRange.prefix + value
+                }));
+            }
+        }
+        return labels;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/DateTimeVisualBinRange.ts b/src/client/northstar/model/binRanges/DateTimeVisualBinRange.ts
new file mode 100644
index 000000000..9313fb1a7
--- /dev/null
+++ b/src/client/northstar/model/binRanges/DateTimeVisualBinRange.ts
@@ -0,0 +1,105 @@
+import { DateTimeBinRange, DateTimeStep, DateTimeStepGranularity } from '../idea/idea'
+import { VisualBinRange } from './VisualBinRange'
+
+export class DateTimeVisualBinRange extends VisualBinRange {
+    public DataBinRange: DateTimeBinRange;
+
+    constructor(dataBinRange: DateTimeBinRange) {
+        super();
+        this.DataBinRange = dataBinRange;
+    }
+
+    public AddStep(value: number): number {
+        return DateTimeVisualBinRange.AddToDateTimeTicks(value, this.DataBinRange.step!);
+    }
+
+    public GetValueFromIndex(index: number): number {
+        var v = this.DataBinRange.minValue!;
+        for (var i = 0; i < index; i++) {
+            v = this.AddStep(v);
+        }
+        return v;
+    }
+
+    public GetBins(): number[] {
+        var bins = new Array<number>();
+        for (var v: number = this.DataBinRange.minValue!;
+            v < this.DataBinRange.maxValue!;
+            v = DateTimeVisualBinRange.AddToDateTimeTicks(v, this.DataBinRange.step!)) {
+            bins.push(v);
+        }
+        return bins;
+    }
+
+    private pad(n: number, size: number) {
+        var sign = n < 0 ? '-' : '';
+        return sign + new Array(size).concat([Math.abs(n)]).join('0').slice(-size);
+    }
+
+
+    public GetLabel(value: number): string {
+        var dt = DateTimeVisualBinRange.TicksToDate(value);
+        if (this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Second ||
+            this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Minute) {
+            return ("" + this.pad(dt.getMinutes(), 2) + ":" + this.pad(dt.getSeconds(), 2));
+            //return dt.ToString("mm:ss");
+        }
+        else if (this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Hour) {
+            return (this.pad(dt.getHours(), 2) + ":" + this.pad(dt.getMinutes(), 2));
+            //return dt.ToString("HH:mm");
+        }
+        else if (this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Day) {
+            return ((dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear());
+            //return dt.ToString("MM/dd/yyyy");
+        }
+        else if (this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Month) {
+            //return dt.ToString("MM/yyyy");
+            return ((dt.getMonth() + 1) + "/" + dt.getFullYear());
+        }
+        else if (this.DataBinRange.step!.dateTimeStepGranularity == DateTimeStepGranularity.Year) {
+            return "" + dt.getFullYear();
+        }
+        return "n/a";
+    }
+
+    public static TicksToDate(ticks: number): Date {
+        var dd = new Date((ticks - 621355968000000000) / 10000);
+        dd.setMinutes(dd.getMinutes() + dd.getTimezoneOffset());
+        return dd;
+    }
+
+
+    public static DateToTicks(date: Date): number {
+        var copiedDate = new Date(date.getTime());
+        copiedDate.setMinutes(copiedDate.getMinutes() - copiedDate.getTimezoneOffset());
+        var t = copiedDate.getTime() * 10000 + 621355968000000000;
+        /*var dd = new Date((ticks - 621355968000000000) / 10000);
+        dd.setMinutes(dd.getMinutes() + dd.getTimezoneOffset());
+        return dd;*/
+        return t;
+    }
+
+    public static AddToDateTimeTicks(ticks: number, dateTimeStep: DateTimeStep): number {
+        var copiedDate = DateTimeVisualBinRange.TicksToDate(ticks);
+        var returnDate: Date = new Date(Date.now());
+        if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Second) {
+            returnDate = new Date(copiedDate.setSeconds(copiedDate.getSeconds() + dateTimeStep.dateTimeStepValue!));
+        }
+        else if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Minute) {
+            returnDate = new Date(copiedDate.setMinutes(copiedDate.getMinutes() + dateTimeStep.dateTimeStepValue!));
+        }
+        else if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Hour) {
+            returnDate = new Date(copiedDate.setHours(copiedDate.getHours() + dateTimeStep.dateTimeStepValue!));
+        }
+        else if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Day) {
+            returnDate = new Date(copiedDate.setDate(copiedDate.getDate() + dateTimeStep.dateTimeStepValue!));
+        }
+        else if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Month) {
+            returnDate = new Date(copiedDate.setMonth(copiedDate.getMonth() + dateTimeStep.dateTimeStepValue!));
+        }
+        else if (dateTimeStep.dateTimeStepGranularity == DateTimeStepGranularity.Year) {
+            returnDate = new Date(copiedDate.setFullYear(copiedDate.getFullYear() + dateTimeStep.dateTimeStepValue!));
+        }
+        return DateTimeVisualBinRange.DateToTicks(returnDate);
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/NominalVisualBinRange.ts b/src/client/northstar/model/binRanges/NominalVisualBinRange.ts
new file mode 100644
index 000000000..407ff3ea6
--- /dev/null
+++ b/src/client/northstar/model/binRanges/NominalVisualBinRange.ts
@@ -0,0 +1,52 @@
+import { NominalBinRange, BinLabel } from '../../model/idea/idea'
+import { VisualBinRange } from './VisualBinRange'
+
+export class NominalVisualBinRange extends VisualBinRange {
+    public DataBinRange: NominalBinRange;
+
+    constructor(dataBinRange: NominalBinRange) {
+        super();
+        this.DataBinRange = dataBinRange;
+    }
+
+    public AddStep(value: number): number {
+        return value + 1;
+    }
+
+    public GetValueFromIndex(index: number): number {
+        return index;
+    }
+
+    public GetBins(): number[] {
+        var bins = new Array<number>();
+        var idx = 0;
+        for (var key in this.DataBinRange.labelsValue) {
+            if (this.DataBinRange.labelsValue.hasOwnProperty(key)) {
+                bins.push(idx);
+                idx++;
+            }
+        }
+        return bins;
+    }
+
+    public GetLabel(value: number): string {
+        return this.DataBinRange.valuesLabel![value];
+    }
+
+    public GetLabels(): Array<BinLabel> {
+        var labels = new Array<BinLabel>();
+        var count = 0;
+        for (var key in this.DataBinRange.valuesLabel) {
+            if (this.DataBinRange.valuesLabel.hasOwnProperty(key)) {
+                var value = this.DataBinRange.valuesLabel[key];
+                labels.push(new BinLabel({
+                    value: parseFloat(key),
+                    minValue: count++,
+                    maxValue: count,
+                    label: value
+                }));
+            }
+        }
+        return labels;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/QuantitativeVisualBinRange.ts b/src/client/northstar/model/binRanges/QuantitativeVisualBinRange.ts
new file mode 100644
index 000000000..80886416b
--- /dev/null
+++ b/src/client/northstar/model/binRanges/QuantitativeVisualBinRange.ts
@@ -0,0 +1,90 @@
+import { QuantitativeBinRange } from '../idea/idea'
+import { VisualBinRange } from './VisualBinRange';
+import { format } from "d3-format";
+
+export class QuantitativeVisualBinRange extends VisualBinRange {
+
+    public DataBinRange: QuantitativeBinRange;
+
+    constructor(dataBinRange: QuantitativeBinRange) {
+        super();
+        this.DataBinRange = dataBinRange;
+    }
+
+    public AddStep(value: number): number {
+        return value + this.DataBinRange.step!;
+    }
+
+    public GetValueFromIndex(index: number): number {
+        return this.DataBinRange.minValue! + (index * this.DataBinRange.step!);
+    }
+
+    public GetLabel(value: number): string {
+        return QuantitativeVisualBinRange.NumberFormatter(value);
+    }
+
+    public static NumberFormatter(val: number): string {
+        if (val === 0) {
+            return "0";
+        }
+        if (val < 1) {
+            /*if (val < Math.abs(0.001))  {
+                return val.toExponential(2);
+            }*/
+            return format(".3")(val);
+        }
+        return format("~s")(val);
+    }
+
+    public GetBins(): number[] {
+        let bins = new Array<number>();
+
+        for (let v: number = this.DataBinRange.minValue!; v < this.DataBinRange.maxValue!; v += this.DataBinRange.step!) {
+            bins.push(v);
+        }
+        return bins;
+    }
+
+    public static Initialize(dataMinValue: number, dataMaxValue: number, targetBinNumber: number, isIntegerRange: boolean): QuantitativeVisualBinRange {
+        let extent = QuantitativeVisualBinRange.getExtent(dataMinValue, dataMaxValue, targetBinNumber, isIntegerRange);
+        let dataBinRange = new QuantitativeBinRange();
+        dataBinRange.minValue = extent[0];
+        dataBinRange.maxValue = extent[1];
+        dataBinRange.step = extent[2];
+
+        return new QuantitativeVisualBinRange(dataBinRange);
+    }
+
+    private static getExtent(dataMin: number, dataMax: number, m: number, isIntegerRange: boolean): number[] {
+        if (dataMin === dataMax) {
+            // dataMin -= 0.1;
+            dataMax += 0.1;
+        }
+        let span = dataMax - dataMin;
+
+        let step = Math.pow(10, Math.floor(Math.log10(span / m)));
+        let err = m / span * step;
+
+        if (err <= .15) {
+            step *= 10;
+        }
+        else if (err <= .35) {
+            step *= 5;
+        }
+        else if (err <= .75) {
+            step *= 2;
+        }
+
+        if (isIntegerRange) {
+            step = Math.ceil(step);
+        }
+        let ret: number[] = new Array<number>(3);
+        let minDivStep = Math.floor(dataMin / step);
+        let maxDivStep = Math.floor(dataMax / step);
+        ret[0] = minDivStep * step; // Math.floor(Math.Round(dataMin, 8)/step)*step;
+        ret[1] = maxDivStep * step + step; // Math.floor(Math.Round(dataMax, 8)/step)*step + step;
+        ret[2] = step;
+
+        return ret;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/VisualBinRange.ts b/src/client/northstar/model/binRanges/VisualBinRange.ts
new file mode 100644
index 000000000..f53008f9a
--- /dev/null
+++ b/src/client/northstar/model/binRanges/VisualBinRange.ts
@@ -0,0 +1,36 @@
+import { BinLabel } from '../../model/idea/idea'
+
+export abstract class VisualBinRange {
+
+    constructor() {
+
+    }
+
+    public abstract AddStep(value: number): number;
+
+    public abstract GetValueFromIndex(index: number): number;
+
+    public abstract GetBins(): Array<number>;
+
+    public GetLabel(value: number): string {
+        return value.toString();
+    }
+
+    public GetLabels(): Array<BinLabel> {
+        var labels = new Array<BinLabel>();
+        var bins = this.GetBins();
+        bins.forEach(b => {
+            labels.push(new BinLabel({
+                value: b,
+                minValue: b,
+                maxValue: this.AddStep(b),
+                label: this.GetLabel(b)
+            }));
+        });
+        return labels;
+    }
+}
+
+export enum ChartType {
+    HorizontalBar = 0, VerticalBar = 1, HeatMap = 2, SinglePoint = 3
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/binRanges/VisualBinRangeHelper.ts b/src/client/northstar/model/binRanges/VisualBinRangeHelper.ts
new file mode 100644
index 000000000..53d585bb4
--- /dev/null
+++ b/src/client/northstar/model/binRanges/VisualBinRangeHelper.ts
@@ -0,0 +1,71 @@
+import { BinRange, NominalBinRange, QuantitativeBinRange, Exception, AlphabeticBinRange, DateTimeBinRange, AggregateBinRange, DoubleValueAggregateResult, HistogramResult, AttributeParameters } from "../idea/idea";
+import { VisualBinRange, ChartType } from "./VisualBinRange";
+import { NominalVisualBinRange } from "./NominalVisualBinRange";
+import { QuantitativeVisualBinRange } from "./QuantitativeVisualBinRange";
+import { AlphabeticVisualBinRange } from "./AlphabeticVisualBinRange";
+import { DateTimeVisualBinRange } from "./DateTimeVisualBinRange";
+import { Settings } from "../../manager/Gateway";
+import { ModelHelpers } from "../ModelHelpers";
+import { AttributeTransformationModel } from "../../core/attribute/AttributeTransformationModel";
+
+export const SETTINGS_X_BINS = 15;
+export const SETTINGS_Y_BINS = 15;
+export const SETTINGS_SAMPLE_SIZE = 100000;
+
+export class VisualBinRangeHelper {
+
+    public static GetNonAggregateVisualBinRange(dataBinRange: BinRange): VisualBinRange {
+        if (dataBinRange instanceof NominalBinRange) {
+            return new NominalVisualBinRange(dataBinRange as NominalBinRange);
+        }
+        else if (dataBinRange instanceof QuantitativeBinRange) {
+            return new QuantitativeVisualBinRange(dataBinRange as QuantitativeBinRange);
+        }
+        else if (dataBinRange instanceof AlphabeticBinRange) {
+            return new AlphabeticVisualBinRange(dataBinRange as AlphabeticBinRange);
+        }
+        else if (dataBinRange instanceof DateTimeBinRange) {
+            return new DateTimeVisualBinRange(dataBinRange as DateTimeBinRange);
+        }
+        throw new Exception()
+    }
+
+    public static GetVisualBinRange(distinctAttributeParameters: AttributeParameters | undefined, dataBinRange: BinRange, histoResult: HistogramResult, attr: AttributeTransformationModel, chartType: ChartType): VisualBinRange {
+
+        if (!(dataBinRange instanceof AggregateBinRange)) {
+            return VisualBinRangeHelper.GetNonAggregateVisualBinRange(dataBinRange);
+        }
+        else {
+            var aggregateKey = ModelHelpers.CreateAggregateKey(distinctAttributeParameters, attr, histoResult, ModelHelpers.AllBrushIndex(histoResult));
+            var minValue = Number.MAX_VALUE;
+            var maxValue = Number.MIN_VALUE;
+            for (var b = 0; b < histoResult.brushes!.length; b++) {
+                var brush = histoResult.brushes![b];
+                aggregateKey.brushIndex = brush.brushIndex;
+                for (var key in histoResult.bins) {
+                    if (histoResult.bins.hasOwnProperty(key)) {
+                        var bin = histoResult.bins[key];
+                        var res = <DoubleValueAggregateResult>ModelHelpers.GetAggregateResult(bin, aggregateKey);
+                        if (res && res.hasResult && res.result) {
+                            minValue = Math.min(minValue, res.result);
+                            maxValue = Math.max(maxValue, res.result);
+                        }
+                    }
+                }
+            };
+
+            let visualBinRange = QuantitativeVisualBinRange.Initialize(minValue, maxValue, 10, false);
+
+            if (chartType == ChartType.HorizontalBar || chartType == ChartType.VerticalBar) {
+                visualBinRange = QuantitativeVisualBinRange.Initialize(Math.min(0, minValue),
+                    Math.max(0, (visualBinRange as QuantitativeVisualBinRange).DataBinRange.maxValue!),
+                    SETTINGS_X_BINS, false);
+            }
+            else if (chartType == ChartType.SinglePoint) {
+                visualBinRange = QuantitativeVisualBinRange.Initialize(Math.min(0, minValue), Math.max(0, maxValue),
+                    SETTINGS_X_BINS, false);
+            }
+            return visualBinRange;
+        }
+    }
+}
diff --git a/src/client/northstar/model/idea/MetricTypeMapping.ts b/src/client/northstar/model/idea/MetricTypeMapping.ts
new file mode 100644
index 000000000..11e0c871a
--- /dev/null
+++ b/src/client/northstar/model/idea/MetricTypeMapping.ts
@@ -0,0 +1,30 @@
+import { MetricType } from "./Idea";
+import { Dictionary } from 'typescript-collections';
+
+
+export class MetricTypeMapping {
+
+    public static GetMetricInterpretation(metricType: MetricType): MetricInterpretation {
+        if (metricType == MetricType.Accuracy ||
+            metricType == MetricType.F1 ||
+            metricType == MetricType.F1Macro ||
+            metricType == MetricType.F1Micro ||
+            metricType == MetricType.JaccardSimilarityScore ||
+            metricType == MetricType.ObjectDetectionAveragePrecision ||
+            metricType == MetricType.Precision ||
+            metricType == MetricType.PrecisionAtTopK ||
+            metricType == MetricType.NormalizedMutualInformation ||
+            metricType == MetricType.Recall ||
+            metricType == MetricType.RocAucMacro ||
+            metricType == MetricType.RocAuc ||
+            metricType == MetricType.RocAucMicro ||
+            metricType == MetricType.RSquared) {
+            return MetricInterpretation.HigherIsBetter;
+        }
+        return MetricInterpretation.LowerIsBetter;
+    }
+}
+
+export enum MetricInterpretation {
+    HigherIsBetter, LowerIsBetter
+}
\ No newline at end of file
diff --git a/src/client/northstar/model/idea/idea.ts b/src/client/northstar/model/idea/idea.ts
new file mode 100644
index 000000000..9d9d60678
--- /dev/null
+++ b/src/client/northstar/model/idea/idea.ts
@@ -0,0 +1,8551 @@
+/* tslint:disable */
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v11.19.2.0 (NJsonSchema v9.10.73.0 (Newtonsoft.Json v9.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+// ReSharper disable InconsistentNaming
+
+
+
+export enum AggregateFunction {
+    None = "None",
+    Sum = "Sum",
+    SumE = "SumE",
+    Count = "Count",
+    Min = "Min",
+    Max = "Max",
+    Avg = "Avg",
+}
+
+export abstract class AggregateParameters implements IAggregateParameters {
+
+    protected _discriminator: string;
+
+    constructor(data?: IAggregateParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "AggregateParameters";
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): AggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "AverageAggregateParameters") {
+            let result = new AverageAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SingleDimensionAggregateParameters") {
+            throw new Error("The abstract class 'SingleDimensionAggregateParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "CountAggregateParameters") {
+            let result = new CountAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KDEAggregateParameters") {
+            let result = new KDEAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MarginAggregateParameters") {
+            let result = new MarginAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MaxAggregateParameters") {
+            let result = new MaxAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MinAggregateParameters") {
+            let result = new MinAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SumAggregateParameters") {
+            let result = new SumAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SumEstimationAggregateParameters") {
+            let result = new SumEstimationAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'AggregateParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        return data;
+    }
+}
+
+export interface IAggregateParameters {
+}
+
+export abstract class SingleDimensionAggregateParameters extends AggregateParameters implements ISingleDimensionAggregateParameters {
+    attributeParameters?: AttributeParameters | undefined;
+    distinctAttributeParameters?: AttributeParameters | undefined;
+
+    constructor(data?: ISingleDimensionAggregateParameters) {
+        super(data);
+        this._discriminator = "SingleDimensionAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.attributeParameters = data["AttributeParameters"] ? AttributeParameters.fromJS(data["AttributeParameters"]) : <any>undefined;
+            this.distinctAttributeParameters = data["DistinctAttributeParameters"] ? AttributeParameters.fromJS(data["DistinctAttributeParameters"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): SingleDimensionAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "AverageAggregateParameters") {
+            let result = new AverageAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CountAggregateParameters") {
+            let result = new CountAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KDEAggregateParameters") {
+            let result = new KDEAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MarginAggregateParameters") {
+            let result = new MarginAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MaxAggregateParameters") {
+            let result = new MaxAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "MinAggregateParameters") {
+            let result = new MinAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SumAggregateParameters") {
+            let result = new SumAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SumEstimationAggregateParameters") {
+            let result = new SumEstimationAggregateParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'SingleDimensionAggregateParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AttributeParameters"] = this.attributeParameters ? this.attributeParameters.toJSON() : <any>undefined;
+        data["DistinctAttributeParameters"] = this.distinctAttributeParameters ? this.distinctAttributeParameters.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISingleDimensionAggregateParameters extends IAggregateParameters {
+    attributeParameters?: AttributeParameters | undefined;
+    distinctAttributeParameters?: AttributeParameters | undefined;
+}
+
+export class AverageAggregateParameters extends SingleDimensionAggregateParameters implements IAverageAggregateParameters {
+
+    constructor(data?: IAverageAggregateParameters) {
+        super(data);
+        this._discriminator = "AverageAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): AverageAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new AverageAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAverageAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export abstract class AttributeParameters implements IAttributeParameters {
+    visualizationHints?: VisualizationHint[] | undefined;
+    rawName?: string | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IAttributeParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "AttributeParameters";
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["VisualizationHints"] && data["VisualizationHints"].constructor === Array) {
+                this.visualizationHints = [];
+                for (let item of data["VisualizationHints"])
+                    this.visualizationHints.push(item);
+            }
+            this.rawName = data["RawName"];
+        }
+    }
+
+    static fromJS(data: any): AttributeParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "AttributeBackendParameters") {
+            let result = new AttributeBackendParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AttributeCaclculatedParameters") {
+            throw new Error("The abstract class 'AttributeCaclculatedParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "AttributeCodeParameters") {
+            let result = new AttributeCodeParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AttributeColumnParameters") {
+            let result = new AttributeColumnParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'AttributeParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        if (this.visualizationHints && this.visualizationHints.constructor === Array) {
+            data["VisualizationHints"] = [];
+            for (let item of this.visualizationHints)
+                data["VisualizationHints"].push(item);
+        }
+        data["RawName"] = this.rawName;
+        return data;
+    }
+}
+
+export interface IAttributeParameters {
+    visualizationHints?: VisualizationHint[] | undefined;
+    rawName?: string | undefined;
+}
+
+export enum VisualizationHint {
+    TreatAsEnumeration = "TreatAsEnumeration",
+    DefaultFlipAxis = "DefaultFlipAxis",
+    Image = "Image",
+}
+
+export abstract class AttributeCaclculatedParameters extends AttributeParameters implements IAttributeCaclculatedParameters {
+
+    constructor(data?: IAttributeCaclculatedParameters) {
+        super(data);
+        this._discriminator = "AttributeCaclculatedParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): AttributeCaclculatedParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "AttributeBackendParameters") {
+            let result = new AttributeBackendParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AttributeCodeParameters") {
+            let result = new AttributeCodeParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'AttributeCaclculatedParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAttributeCaclculatedParameters extends IAttributeParameters {
+}
+
+export class AttributeBackendParameters extends AttributeCaclculatedParameters implements IAttributeBackendParameters {
+    id?: string | undefined;
+
+    constructor(data?: IAttributeBackendParameters) {
+        super(data);
+        this._discriminator = "AttributeBackendParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.id = data["Id"];
+        }
+    }
+
+    static fromJS(data: any): AttributeBackendParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new AttributeBackendParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAttributeBackendParameters extends IAttributeCaclculatedParameters {
+    id?: string | undefined;
+}
+
+export class AttributeCodeParameters extends AttributeCaclculatedParameters implements IAttributeCodeParameters {
+    code?: string | undefined;
+
+    constructor(data?: IAttributeCodeParameters) {
+        super(data);
+        this._discriminator = "AttributeCodeParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.code = data["Code"];
+        }
+    }
+
+    static fromJS(data: any): AttributeCodeParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new AttributeCodeParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Code"] = this.code;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAttributeCodeParameters extends IAttributeCaclculatedParameters {
+    code?: string | undefined;
+}
+
+export class AttributeColumnParameters extends AttributeParameters implements IAttributeColumnParameters {
+
+    constructor(data?: IAttributeColumnParameters) {
+        super(data);
+        this._discriminator = "AttributeColumnParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): AttributeColumnParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new AttributeColumnParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAttributeColumnParameters extends IAttributeParameters {
+}
+
+export class CountAggregateParameters extends SingleDimensionAggregateParameters implements ICountAggregateParameters {
+
+    constructor(data?: ICountAggregateParameters) {
+        super(data);
+        this._discriminator = "CountAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): CountAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new CountAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICountAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export class KDEAggregateParameters extends SingleDimensionAggregateParameters implements IKDEAggregateParameters {
+    nrOfSamples?: number | undefined;
+
+    constructor(data?: IKDEAggregateParameters) {
+        super(data);
+        this._discriminator = "KDEAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.nrOfSamples = data["NrOfSamples"];
+        }
+    }
+
+    static fromJS(data: any): KDEAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new KDEAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["NrOfSamples"] = this.nrOfSamples;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IKDEAggregateParameters extends ISingleDimensionAggregateParameters {
+    nrOfSamples?: number | undefined;
+}
+
+export class MarginAggregateParameters extends SingleDimensionAggregateParameters implements IMarginAggregateParameters {
+    aggregateFunction?: AggregateFunction | undefined;
+
+    constructor(data?: IMarginAggregateParameters) {
+        super(data);
+        this._discriminator = "MarginAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.aggregateFunction = data["AggregateFunction"];
+        }
+    }
+
+    static fromJS(data: any): MarginAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new MarginAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AggregateFunction"] = this.aggregateFunction;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IMarginAggregateParameters extends ISingleDimensionAggregateParameters {
+    aggregateFunction?: AggregateFunction | undefined;
+}
+
+export class MaxAggregateParameters extends SingleDimensionAggregateParameters implements IMaxAggregateParameters {
+
+    constructor(data?: IMaxAggregateParameters) {
+        super(data);
+        this._discriminator = "MaxAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): MaxAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new MaxAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IMaxAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export class MinAggregateParameters extends SingleDimensionAggregateParameters implements IMinAggregateParameters {
+
+    constructor(data?: IMinAggregateParameters) {
+        super(data);
+        this._discriminator = "MinAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): MinAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new MinAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IMinAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export class SumAggregateParameters extends SingleDimensionAggregateParameters implements ISumAggregateParameters {
+
+    constructor(data?: ISumAggregateParameters) {
+        super(data);
+        this._discriminator = "SumAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): SumAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SumAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISumAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export class SumEstimationAggregateParameters extends SingleDimensionAggregateParameters implements ISumEstimationAggregateParameters {
+
+    constructor(data?: ISumEstimationAggregateParameters) {
+        super(data);
+        this._discriminator = "SumEstimationAggregateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): SumEstimationAggregateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SumEstimationAggregateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISumEstimationAggregateParameters extends ISingleDimensionAggregateParameters {
+}
+
+export enum OrderingFunction {
+    None = 0,
+    SortUp = 1,
+    SortDown = 2,
+}
+
+export abstract class BinningParameters implements IBinningParameters {
+    attributeParameters?: AttributeParameters | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IBinningParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "BinningParameters";
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.attributeParameters = data["AttributeParameters"] ? AttributeParameters.fromJS(data["AttributeParameters"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): BinningParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "EquiWidthBinningParameters") {
+            let result = new EquiWidthBinningParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SingleBinBinningParameters") {
+            let result = new SingleBinBinningParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'BinningParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["AttributeParameters"] = this.attributeParameters ? this.attributeParameters.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface IBinningParameters {
+    attributeParameters?: AttributeParameters | undefined;
+}
+
+export class EquiWidthBinningParameters extends BinningParameters implements IEquiWidthBinningParameters {
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    requestedNrOfBins?: number | undefined;
+    referenceValue?: number | undefined;
+    step?: number | undefined;
+
+    constructor(data?: IEquiWidthBinningParameters) {
+        super(data);
+        this._discriminator = "EquiWidthBinningParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.minValue = data["MinValue"];
+            this.maxValue = data["MaxValue"];
+            this.requestedNrOfBins = data["RequestedNrOfBins"];
+            this.referenceValue = data["ReferenceValue"];
+            this.step = data["Step"];
+        }
+    }
+
+    static fromJS(data: any): EquiWidthBinningParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new EquiWidthBinningParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["MinValue"] = this.minValue;
+        data["MaxValue"] = this.maxValue;
+        data["RequestedNrOfBins"] = this.requestedNrOfBins;
+        data["ReferenceValue"] = this.referenceValue;
+        data["Step"] = this.step;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IEquiWidthBinningParameters extends IBinningParameters {
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    requestedNrOfBins?: number | undefined;
+    referenceValue?: number | undefined;
+    step?: number | undefined;
+}
+
+export class SingleBinBinningParameters extends BinningParameters implements ISingleBinBinningParameters {
+
+    constructor(data?: ISingleBinBinningParameters) {
+        super(data);
+        this._discriminator = "SingleBinBinningParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): SingleBinBinningParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SingleBinBinningParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISingleBinBinningParameters extends IBinningParameters {
+}
+
+export class Attribute implements IAttribute {
+    displayName?: string | undefined;
+    rawName?: string | undefined;
+    description?: string | undefined;
+    dataType?: DataType | undefined;
+    visualizationHints?: VisualizationHint[] | undefined;
+    isTarget?: boolean | undefined;
+
+    constructor(data?: IAttribute) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.displayName = data["DisplayName"];
+            this.rawName = data["RawName"];
+            this.description = data["Description"];
+            this.dataType = data["DataType"];
+            if (data["VisualizationHints"] && data["VisualizationHints"].constructor === Array) {
+                this.visualizationHints = [];
+                for (let item of data["VisualizationHints"])
+                    this.visualizationHints.push(item);
+            }
+            this.isTarget = data["IsTarget"];
+        }
+    }
+
+    static fromJS(data: any): Attribute {
+        data = typeof data === 'object' ? data : {};
+        let result = new Attribute();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["DisplayName"] = this.displayName;
+        data["RawName"] = this.rawName;
+        data["Description"] = this.description;
+        data["DataType"] = this.dataType;
+        if (this.visualizationHints && this.visualizationHints.constructor === Array) {
+            data["VisualizationHints"] = [];
+            for (let item of this.visualizationHints)
+                data["VisualizationHints"].push(item);
+        }
+        data["IsTarget"] = this.isTarget;
+        return data;
+    }
+}
+
+export interface IAttribute {
+    displayName?: string | undefined;
+    rawName?: string | undefined;
+    description?: string | undefined;
+    dataType?: DataType | undefined;
+    visualizationHints?: VisualizationHint[] | undefined;
+    isTarget?: boolean | undefined;
+}
+
+export enum DataType {
+    Int = "Int",
+    String = "String",
+    Float = "Float",
+    Double = "Double",
+    DateTime = "DateTime",
+    Object = "Object",
+    Undefined = "Undefined",
+}
+
+export class AttributeGroup implements IAttributeGroup {
+    name?: string | undefined;
+    attributeGroups?: AttributeGroup[] | undefined;
+    attributes?: Attribute[] | undefined;
+
+    constructor(data?: IAttributeGroup) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.name = data["Name"];
+            if (data["AttributeGroups"] && data["AttributeGroups"].constructor === Array) {
+                this.attributeGroups = [];
+                for (let item of data["AttributeGroups"])
+                    this.attributeGroups.push(AttributeGroup.fromJS(item));
+            }
+            if (data["Attributes"] && data["Attributes"].constructor === Array) {
+                this.attributes = [];
+                for (let item of data["Attributes"])
+                    this.attributes.push(Attribute.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): AttributeGroup {
+        data = typeof data === 'object' ? data : {};
+        let result = new AttributeGroup();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Name"] = this.name;
+        if (this.attributeGroups && this.attributeGroups.constructor === Array) {
+            data["AttributeGroups"] = [];
+            for (let item of this.attributeGroups)
+                data["AttributeGroups"].push(item.toJSON());
+        }
+        if (this.attributes && this.attributes.constructor === Array) {
+            data["Attributes"] = [];
+            for (let item of this.attributes)
+                data["Attributes"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IAttributeGroup {
+    name?: string | undefined;
+    attributeGroups?: AttributeGroup[] | undefined;
+    attributes?: Attribute[] | undefined;
+}
+
+export class Catalog implements ICatalog {
+    supportedOperations?: string[] | undefined;
+    schemas?: Schema[] | undefined;
+
+    constructor(data?: ICatalog) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["SupportedOperations"] && data["SupportedOperations"].constructor === Array) {
+                this.supportedOperations = [];
+                for (let item of data["SupportedOperations"])
+                    this.supportedOperations.push(item);
+            }
+            if (data["Schemas"] && data["Schemas"].constructor === Array) {
+                this.schemas = [];
+                for (let item of data["Schemas"])
+                    this.schemas.push(Schema.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): Catalog {
+        data = typeof data === 'object' ? data : {};
+        let result = new Catalog();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.supportedOperations && this.supportedOperations.constructor === Array) {
+            data["SupportedOperations"] = [];
+            for (let item of this.supportedOperations)
+                data["SupportedOperations"].push(item);
+        }
+        if (this.schemas && this.schemas.constructor === Array) {
+            data["Schemas"] = [];
+            for (let item of this.schemas)
+                data["Schemas"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface ICatalog {
+    supportedOperations?: string[] | undefined;
+    schemas?: Schema[] | undefined;
+}
+
+export class Schema implements ISchema {
+    rootAttributeGroup?: AttributeGroup | undefined;
+    displayName?: string | undefined;
+    augmentedFrom?: string | undefined;
+    rawName?: string | undefined;
+    problemDescription?: string | undefined;
+    darpaProblemDoc?: DarpaProblemDoc | undefined;
+    distinctAttributeParameters?: AttributeParameters | undefined;
+    darpaDatasetDoc?: DarpaDatasetDoc | undefined;
+    darpaDatasetLocation?: string | undefined;
+    isMultiResourceData?: boolean | undefined;
+    problemFinderRows?: ProblemFinderRows[] | undefined;
+    correlationRows?: ProblemFinderRows[] | undefined;
+
+    constructor(data?: ISchema) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.rootAttributeGroup = data["RootAttributeGroup"] ? AttributeGroup.fromJS(data["RootAttributeGroup"]) : <any>undefined;
+            this.displayName = data["DisplayName"];
+            this.augmentedFrom = data["AugmentedFrom"];
+            this.rawName = data["RawName"];
+            this.problemDescription = data["ProblemDescription"];
+            this.darpaProblemDoc = data["DarpaProblemDoc"] ? DarpaProblemDoc.fromJS(data["DarpaProblemDoc"]) : <any>undefined;
+            this.distinctAttributeParameters = data["DistinctAttributeParameters"] ? AttributeParameters.fromJS(data["DistinctAttributeParameters"]) : <any>undefined;
+            this.darpaDatasetDoc = data["DarpaDatasetDoc"] ? DarpaDatasetDoc.fromJS(data["DarpaDatasetDoc"]) : <any>undefined;
+            this.darpaDatasetLocation = data["DarpaDatasetLocation"];
+            this.isMultiResourceData = data["IsMultiResourceData"];
+            if (data["ProblemFinderRows"] && data["ProblemFinderRows"].constructor === Array) {
+                this.problemFinderRows = [];
+                for (let item of data["ProblemFinderRows"])
+                    this.problemFinderRows.push(ProblemFinderRows.fromJS(item));
+            }
+            if (data["CorrelationRows"] && data["CorrelationRows"].constructor === Array) {
+                this.correlationRows = [];
+                for (let item of data["CorrelationRows"])
+                    this.correlationRows.push(ProblemFinderRows.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): Schema {
+        data = typeof data === 'object' ? data : {};
+        let result = new Schema();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["RootAttributeGroup"] = this.rootAttributeGroup ? this.rootAttributeGroup.toJSON() : <any>undefined;
+        data["DisplayName"] = this.displayName;
+        data["AugmentedFrom"] = this.augmentedFrom;
+        data["RawName"] = this.rawName;
+        data["ProblemDescription"] = this.problemDescription;
+        data["DarpaProblemDoc"] = this.darpaProblemDoc ? this.darpaProblemDoc.toJSON() : <any>undefined;
+        data["DistinctAttributeParameters"] = this.distinctAttributeParameters ? this.distinctAttributeParameters.toJSON() : <any>undefined;
+        data["DarpaDatasetDoc"] = this.darpaDatasetDoc ? this.darpaDatasetDoc.toJSON() : <any>undefined;
+        data["DarpaDatasetLocation"] = this.darpaDatasetLocation;
+        data["IsMultiResourceData"] = this.isMultiResourceData;
+        if (this.problemFinderRows && this.problemFinderRows.constructor === Array) {
+            data["ProblemFinderRows"] = [];
+            for (let item of this.problemFinderRows)
+                data["ProblemFinderRows"].push(item.toJSON());
+        }
+        if (this.correlationRows && this.correlationRows.constructor === Array) {
+            data["CorrelationRows"] = [];
+            for (let item of this.correlationRows)
+                data["CorrelationRows"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface ISchema {
+    rootAttributeGroup?: AttributeGroup | undefined;
+    displayName?: string | undefined;
+    augmentedFrom?: string | undefined;
+    rawName?: string | undefined;
+    problemDescription?: string | undefined;
+    darpaProblemDoc?: DarpaProblemDoc | undefined;
+    distinctAttributeParameters?: AttributeParameters | undefined;
+    darpaDatasetDoc?: DarpaDatasetDoc | undefined;
+    darpaDatasetLocation?: string | undefined;
+    isMultiResourceData?: boolean | undefined;
+    problemFinderRows?: ProblemFinderRows[] | undefined;
+    correlationRows?: ProblemFinderRows[] | undefined;
+}
+
+export class DarpaProblemDoc implements IDarpaProblemDoc {
+    about?: ProblemAbout | undefined;
+    inputs?: ProblemInputs | undefined;
+
+    constructor(data?: IDarpaProblemDoc) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.about = data["about"] ? ProblemAbout.fromJS(data["about"]) : <any>undefined;
+            this.inputs = data["inputs"] ? ProblemInputs.fromJS(data["inputs"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): DarpaProblemDoc {
+        data = typeof data === 'object' ? data : {};
+        let result = new DarpaProblemDoc();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["about"] = this.about ? this.about.toJSON() : <any>undefined;
+        data["inputs"] = this.inputs ? this.inputs.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface IDarpaProblemDoc {
+    about?: ProblemAbout | undefined;
+    inputs?: ProblemInputs | undefined;
+}
+
+export class ProblemAbout implements IProblemAbout {
+    problemID?: string | undefined;
+    problemName?: string | undefined;
+    problemDescription?: string | undefined;
+    taskType?: string | undefined;
+    taskSubType?: string | undefined;
+    problemSchemaVersion?: string | undefined;
+    problemVersion?: string | undefined;
+
+    constructor(data?: IProblemAbout) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.problemID = data["problemID"];
+            this.problemName = data["problemName"];
+            this.problemDescription = data["problemDescription"];
+            this.taskType = data["taskType"];
+            this.taskSubType = data["taskSubType"];
+            this.problemSchemaVersion = data["problemSchemaVersion"];
+            this.problemVersion = data["problemVersion"];
+        }
+    }
+
+    static fromJS(data: any): ProblemAbout {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemAbout();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["problemID"] = this.problemID;
+        data["problemName"] = this.problemName;
+        data["problemDescription"] = this.problemDescription;
+        data["taskType"] = this.taskType;
+        data["taskSubType"] = this.taskSubType;
+        data["problemSchemaVersion"] = this.problemSchemaVersion;
+        data["problemVersion"] = this.problemVersion;
+        return data;
+    }
+}
+
+export interface IProblemAbout {
+    problemID?: string | undefined;
+    problemName?: string | undefined;
+    problemDescription?: string | undefined;
+    taskType?: string | undefined;
+    taskSubType?: string | undefined;
+    problemSchemaVersion?: string | undefined;
+    problemVersion?: string | undefined;
+}
+
+export class ProblemInputs implements IProblemInputs {
+    data?: ProblemData[] | undefined;
+    performanceMetrics?: ProblemPerformanceMetric[] | undefined;
+
+    constructor(data?: IProblemInputs) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["data"] && data["data"].constructor === Array) {
+                this.data = [];
+                for (let item of data["data"])
+                    this.data.push(ProblemData.fromJS(item));
+            }
+            if (data["performanceMetrics"] && data["performanceMetrics"].constructor === Array) {
+                this.performanceMetrics = [];
+                for (let item of data["performanceMetrics"])
+                    this.performanceMetrics.push(ProblemPerformanceMetric.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): ProblemInputs {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemInputs();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.data && this.data.constructor === Array) {
+            data["data"] = [];
+            for (let item of this.data)
+                data["data"].push(item.toJSON());
+        }
+        if (this.performanceMetrics && this.performanceMetrics.constructor === Array) {
+            data["performanceMetrics"] = [];
+            for (let item of this.performanceMetrics)
+                data["performanceMetrics"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IProblemInputs {
+    data?: ProblemData[] | undefined;
+    performanceMetrics?: ProblemPerformanceMetric[] | undefined;
+}
+
+export class ProblemData implements IProblemData {
+    datasetID?: string | undefined;
+    targets?: ProblemTarget[] | undefined;
+
+    constructor(data?: IProblemData) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.datasetID = data["datasetID"];
+            if (data["targets"] && data["targets"].constructor === Array) {
+                this.targets = [];
+                for (let item of data["targets"])
+                    this.targets.push(ProblemTarget.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): ProblemData {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemData();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["datasetID"] = this.datasetID;
+        if (this.targets && this.targets.constructor === Array) {
+            data["targets"] = [];
+            for (let item of this.targets)
+                data["targets"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IProblemData {
+    datasetID?: string | undefined;
+    targets?: ProblemTarget[] | undefined;
+}
+
+export class ProblemTarget implements IProblemTarget {
+    targetIndex?: number | undefined;
+    resID?: string | undefined;
+    colIndex?: number | undefined;
+    colName?: string | undefined;
+
+    constructor(data?: IProblemTarget) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.targetIndex = data["targetIndex"];
+            this.resID = data["resID"];
+            this.colIndex = data["colIndex"];
+            this.colName = data["colName"];
+        }
+    }
+
+    static fromJS(data: any): ProblemTarget {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemTarget();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["targetIndex"] = this.targetIndex;
+        data["resID"] = this.resID;
+        data["colIndex"] = this.colIndex;
+        data["colName"] = this.colName;
+        return data;
+    }
+}
+
+export interface IProblemTarget {
+    targetIndex?: number | undefined;
+    resID?: string | undefined;
+    colIndex?: number | undefined;
+    colName?: string | undefined;
+}
+
+export class ProblemPerformanceMetric implements IProblemPerformanceMetric {
+    metric?: string | undefined;
+
+    constructor(data?: IProblemPerformanceMetric) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.metric = data["metric"];
+        }
+    }
+
+    static fromJS(data: any): ProblemPerformanceMetric {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemPerformanceMetric();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["metric"] = this.metric;
+        return data;
+    }
+}
+
+export interface IProblemPerformanceMetric {
+    metric?: string | undefined;
+}
+
+export class DarpaDatasetDoc implements IDarpaDatasetDoc {
+    about?: DatasetAbout | undefined;
+    dataResources?: Resource[] | undefined;
+
+    constructor(data?: IDarpaDatasetDoc) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.about = data["about"] ? DatasetAbout.fromJS(data["about"]) : <any>undefined;
+            if (data["dataResources"] && data["dataResources"].constructor === Array) {
+                this.dataResources = [];
+                for (let item of data["dataResources"])
+                    this.dataResources.push(Resource.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): DarpaDatasetDoc {
+        data = typeof data === 'object' ? data : {};
+        let result = new DarpaDatasetDoc();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["about"] = this.about ? this.about.toJSON() : <any>undefined;
+        if (this.dataResources && this.dataResources.constructor === Array) {
+            data["dataResources"] = [];
+            for (let item of this.dataResources)
+                data["dataResources"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IDarpaDatasetDoc {
+    about?: DatasetAbout | undefined;
+    dataResources?: Resource[] | undefined;
+}
+
+export class DatasetAbout implements IDatasetAbout {
+    datasetID?: string | undefined;
+    datasetName?: string | undefined;
+    description?: string | undefined;
+    citation?: string | undefined;
+    license?: string | undefined;
+    source?: string | undefined;
+    sourceURI?: string | undefined;
+    approximateSize?: string | undefined;
+    datasetSchemaVersion?: string | undefined;
+    redacted?: boolean | undefined;
+    datasetVersion?: string | undefined;
+
+    constructor(data?: IDatasetAbout) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.datasetID = data["datasetID"];
+            this.datasetName = data["datasetName"];
+            this.description = data["description"];
+            this.citation = data["citation"];
+            this.license = data["license"];
+            this.source = data["source"];
+            this.sourceURI = data["sourceURI"];
+            this.approximateSize = data["approximateSize"];
+            this.datasetSchemaVersion = data["datasetSchemaVersion"];
+            this.redacted = data["redacted"];
+            this.datasetVersion = data["datasetVersion"];
+        }
+    }
+
+    static fromJS(data: any): DatasetAbout {
+        data = typeof data === 'object' ? data : {};
+        let result = new DatasetAbout();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["datasetID"] = this.datasetID;
+        data["datasetName"] = this.datasetName;
+        data["description"] = this.description;
+        data["citation"] = this.citation;
+        data["license"] = this.license;
+        data["source"] = this.source;
+        data["sourceURI"] = this.sourceURI;
+        data["approximateSize"] = this.approximateSize;
+        data["datasetSchemaVersion"] = this.datasetSchemaVersion;
+        data["redacted"] = this.redacted;
+        data["datasetVersion"] = this.datasetVersion;
+        return data;
+    }
+}
+
+export interface IDatasetAbout {
+    datasetID?: string | undefined;
+    datasetName?: string | undefined;
+    description?: string | undefined;
+    citation?: string | undefined;
+    license?: string | undefined;
+    source?: string | undefined;
+    sourceURI?: string | undefined;
+    approximateSize?: string | undefined;
+    datasetSchemaVersion?: string | undefined;
+    redacted?: boolean | undefined;
+    datasetVersion?: string | undefined;
+}
+
+export class Resource implements IResource {
+    resID?: string | undefined;
+    resPath?: string | undefined;
+    resType?: string | undefined;
+    resFormat?: string[] | undefined;
+    columns?: Column[] | undefined;
+    isCollection?: boolean | undefined;
+
+    constructor(data?: IResource) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.resID = data["resID"];
+            this.resPath = data["resPath"];
+            this.resType = data["resType"];
+            if (data["resFormat"] && data["resFormat"].constructor === Array) {
+                this.resFormat = [];
+                for (let item of data["resFormat"])
+                    this.resFormat.push(item);
+            }
+            if (data["columns"] && data["columns"].constructor === Array) {
+                this.columns = [];
+                for (let item of data["columns"])
+                    this.columns.push(Column.fromJS(item));
+            }
+            this.isCollection = data["isCollection"];
+        }
+    }
+
+    static fromJS(data: any): Resource {
+        data = typeof data === 'object' ? data : {};
+        let result = new Resource();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["resID"] = this.resID;
+        data["resPath"] = this.resPath;
+        data["resType"] = this.resType;
+        if (this.resFormat && this.resFormat.constructor === Array) {
+            data["resFormat"] = [];
+            for (let item of this.resFormat)
+                data["resFormat"].push(item);
+        }
+        if (this.columns && this.columns.constructor === Array) {
+            data["columns"] = [];
+            for (let item of this.columns)
+                data["columns"].push(item.toJSON());
+        }
+        data["isCollection"] = this.isCollection;
+        return data;
+    }
+}
+
+export interface IResource {
+    resID?: string | undefined;
+    resPath?: string | undefined;
+    resType?: string | undefined;
+    resFormat?: string[] | undefined;
+    columns?: Column[] | undefined;
+    isCollection?: boolean | undefined;
+}
+
+export class Column implements IColumn {
+    colIndex?: number | undefined;
+    colDescription?: string | undefined;
+    colName?: string | undefined;
+    colType?: string | undefined;
+    role?: string[] | undefined;
+    refersTo?: Reference | undefined;
+
+    constructor(data?: IColumn) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.colIndex = data["colIndex"];
+            this.colDescription = data["colDescription"];
+            this.colName = data["colName"];
+            this.colType = data["colType"];
+            if (data["role"] && data["role"].constructor === Array) {
+                this.role = [];
+                for (let item of data["role"])
+                    this.role.push(item);
+            }
+            this.refersTo = data["refersTo"] ? Reference.fromJS(data["refersTo"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): Column {
+        data = typeof data === 'object' ? data : {};
+        let result = new Column();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["colIndex"] = this.colIndex;
+        data["colDescription"] = this.colDescription;
+        data["colName"] = this.colName;
+        data["colType"] = this.colType;
+        if (this.role && this.role.constructor === Array) {
+            data["role"] = [];
+            for (let item of this.role)
+                data["role"].push(item);
+        }
+        data["refersTo"] = this.refersTo ? this.refersTo.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface IColumn {
+    colIndex?: number | undefined;
+    colDescription?: string | undefined;
+    colName?: string | undefined;
+    colType?: string | undefined;
+    role?: string[] | undefined;
+    refersTo?: Reference | undefined;
+}
+
+export class Reference implements IReference {
+    resID?: string | undefined;
+
+    constructor(data?: IReference) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.resID = data["resID"];
+        }
+    }
+
+    static fromJS(data: any): Reference {
+        data = typeof data === 'object' ? data : {};
+        let result = new Reference();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["resID"] = this.resID;
+        return data;
+    }
+}
+
+export interface IReference {
+    resID?: string | undefined;
+}
+
+export class ProblemFinderRows implements IProblemFinderRows {
+    label?: string | undefined;
+    type?: string | undefined;
+    features?: Feature[] | undefined;
+
+    constructor(data?: IProblemFinderRows) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.label = data["label"];
+            this.type = data["type"];
+            if (data["features"] && data["features"].constructor === Array) {
+                this.features = [];
+                for (let item of data["features"])
+                    this.features.push(Feature.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): ProblemFinderRows {
+        data = typeof data === 'object' ? data : {};
+        let result = new ProblemFinderRows();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["label"] = this.label;
+        data["type"] = this.type;
+        if (this.features && this.features.constructor === Array) {
+            data["features"] = [];
+            for (let item of this.features)
+                data["features"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IProblemFinderRows {
+    label?: string | undefined;
+    type?: string | undefined;
+    features?: Feature[] | undefined;
+}
+
+export class Feature implements IFeature {
+    name?: string | undefined;
+    selected?: boolean | undefined;
+    value?: number | undefined;
+
+    constructor(data?: IFeature) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.name = data["name"];
+            this.selected = data["selected"];
+            this.value = data["value"];
+        }
+    }
+
+    static fromJS(data: any): Feature {
+        data = typeof data === 'object' ? data : {};
+        let result = new Feature();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["name"] = this.name;
+        data["selected"] = this.selected;
+        data["value"] = this.value;
+        return data;
+    }
+}
+
+export interface IFeature {
+    name?: string | undefined;
+    selected?: boolean | undefined;
+    value?: number | undefined;
+}
+
+export enum DataType2 {
+    Int = 0,
+    String = 1,
+    Float = 2,
+    Double = 3,
+    DateTime = 4,
+    Object = 5,
+    Undefined = 6,
+}
+
+export abstract class DataTypeExtensions implements IDataTypeExtensions {
+
+    constructor(data?: IDataTypeExtensions) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): DataTypeExtensions {
+        data = typeof data === 'object' ? data : {};
+        throw new Error("The abstract class 'DataTypeExtensions' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        return data;
+    }
+}
+
+export interface IDataTypeExtensions {
+}
+
+export class ResObject implements IResObject {
+    columnName?: string | undefined;
+
+    constructor(data?: IResObject) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.columnName = data["columnName"];
+        }
+    }
+
+    static fromJS(data: any): ResObject {
+        data = typeof data === 'object' ? data : {};
+        let result = new ResObject();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["columnName"] = this.columnName;
+        return data;
+    }
+}
+
+export interface IResObject {
+    columnName?: string | undefined;
+}
+
+export class Exception implements IException {
+    message?: string | undefined;
+    innerException?: Exception | undefined;
+    stackTrace?: string | undefined;
+    source?: string | undefined;
+
+    constructor(data?: IException) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.message = data["Message"];
+            this.innerException = data["InnerException"] ? Exception.fromJS(data["InnerException"]) : <any>undefined;
+            this.stackTrace = data["StackTrace"];
+            this.source = data["Source"];
+        }
+    }
+
+    static fromJS(data: any): Exception {
+        data = typeof data === 'object' ? data : {};
+        let result = new Exception();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Message"] = this.message;
+        data["InnerException"] = this.innerException ? this.innerException.toJSON() : <any>undefined;
+        data["StackTrace"] = this.stackTrace;
+        data["Source"] = this.source;
+        return data;
+    }
+}
+
+export interface IException {
+    message?: string | undefined;
+    innerException?: Exception | undefined;
+    stackTrace?: string | undefined;
+    source?: string | undefined;
+}
+
+export class IDEAException extends Exception implements IIDEAException {
+
+    constructor(data?: IIDEAException) {
+        super(data);
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): IDEAException {
+        data = typeof data === 'object' ? data : {};
+        let result = new IDEAException();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IIDEAException extends IException {
+}
+
+export class CodeParameters implements ICodeParameters {
+    attributeCodeParameters?: AttributeCodeParameters[] | undefined;
+    adapterName?: string | undefined;
+
+    constructor(data?: ICodeParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["AttributeCodeParameters"] && data["AttributeCodeParameters"].constructor === Array) {
+                this.attributeCodeParameters = [];
+                for (let item of data["AttributeCodeParameters"])
+                    this.attributeCodeParameters.push(AttributeCodeParameters.fromJS(item));
+            }
+            this.adapterName = data["AdapterName"];
+        }
+    }
+
+    static fromJS(data: any): CodeParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new CodeParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.attributeCodeParameters && this.attributeCodeParameters.constructor === Array) {
+            data["AttributeCodeParameters"] = [];
+            for (let item of this.attributeCodeParameters)
+                data["AttributeCodeParameters"].push(item.toJSON());
+        }
+        data["AdapterName"] = this.adapterName;
+        return data;
+    }
+}
+
+export interface ICodeParameters {
+    attributeCodeParameters?: AttributeCodeParameters[] | undefined;
+    adapterName?: string | undefined;
+}
+
+export class CompileResult implements ICompileResult {
+    compileSuccess?: boolean | undefined;
+    compileMessage?: string | undefined;
+    dataType?: DataType | undefined;
+    replaceAttributeParameters?: AttributeParameters[] | undefined;
+
+    constructor(data?: ICompileResult) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.compileSuccess = data["CompileSuccess"];
+            this.compileMessage = data["CompileMessage"];
+            this.dataType = data["DataType"];
+            if (data["ReplaceAttributeParameters"] && data["ReplaceAttributeParameters"].constructor === Array) {
+                this.replaceAttributeParameters = [];
+                for (let item of data["ReplaceAttributeParameters"])
+                    this.replaceAttributeParameters.push(AttributeParameters.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): CompileResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new CompileResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["CompileSuccess"] = this.compileSuccess;
+        data["CompileMessage"] = this.compileMessage;
+        data["DataType"] = this.dataType;
+        if (this.replaceAttributeParameters && this.replaceAttributeParameters.constructor === Array) {
+            data["ReplaceAttributeParameters"] = [];
+            for (let item of this.replaceAttributeParameters)
+                data["ReplaceAttributeParameters"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface ICompileResult {
+    compileSuccess?: boolean | undefined;
+    compileMessage?: string | undefined;
+    dataType?: DataType | undefined;
+    replaceAttributeParameters?: AttributeParameters[] | undefined;
+}
+
+export class CompileResults implements ICompileResults {
+    rawNameToCompileResult?: { [key: string]: CompileResult; } | undefined;
+
+    constructor(data?: ICompileResults) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["RawNameToCompileResult"]) {
+                this.rawNameToCompileResult = {};
+                for (let key in data["RawNameToCompileResult"]) {
+                    if (data["RawNameToCompileResult"].hasOwnProperty(key))
+                        this.rawNameToCompileResult[key] = data["RawNameToCompileResult"][key] ? CompileResult.fromJS(data["RawNameToCompileResult"][key]) : new CompileResult();
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): CompileResults {
+        data = typeof data === 'object' ? data : {};
+        let result = new CompileResults();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.rawNameToCompileResult) {
+            data["RawNameToCompileResult"] = {};
+            for (let key in this.rawNameToCompileResult) {
+                if (this.rawNameToCompileResult.hasOwnProperty(key))
+                    data["RawNameToCompileResult"][key] = this.rawNameToCompileResult[key];
+            }
+        }
+        return data;
+    }
+}
+
+export interface ICompileResults {
+    rawNameToCompileResult?: { [key: string]: CompileResult; } | undefined;
+}
+
+export abstract class UniqueJson implements IUniqueJson {
+
+    constructor(data?: IUniqueJson) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): UniqueJson {
+        data = typeof data === 'object' ? data : {};
+        throw new Error("The abstract class 'UniqueJson' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        return data;
+    }
+}
+
+export interface IUniqueJson {
+}
+
+export abstract class OperationParameters extends UniqueJson implements IOperationParameters {
+    isCachable?: boolean | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IOperationParameters) {
+        super(data);
+        this._discriminator = "OperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.isCachable = data["IsCachable"];
+        }
+    }
+
+    static fromJS(data: any): OperationParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "DataOperationParameters") {
+            throw new Error("The abstract class 'DataOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "ExampleOperationParameters") {
+            let result = new ExampleOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "HistogramOperationParameters") {
+            let result = new HistogramOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DistOperationParameters") {
+            throw new Error("The abstract class 'DistOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "OptimizerOperationParameters") {
+            let result = new OptimizerOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RawDataOperationParameters") {
+            let result = new RawDataOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RecommenderOperationParameters") {
+            let result = new RecommenderOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CDFOperationParameters") {
+            let result = new CDFOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TestDistOperationParameters") {
+            throw new Error("The abstract class 'TestDistOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "ChiSquaredTestOperationParameters") {
+            let result = new ChiSquaredTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "HypothesisTestParameters") {
+            throw new Error("The abstract class 'HypothesisTestParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "CorrelationTestOperationParameters") {
+            let result = new CorrelationTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "EmpiricalDistOperationParameters") {
+            let result = new EmpiricalDistOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KSTestOperationParameters") {
+            let result = new KSTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "NewModelOperationParameters") {
+            let result = new NewModelOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ModelOperationParameters") {
+            throw new Error("The abstract class 'ModelOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "RootMeanSquareTestOperationParameters") {
+            let result = new RootMeanSquareTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TTestOperationParameters") {
+            let result = new TTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FeatureImportanceOperationParameters") {
+            let result = new FeatureImportanceOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SampleOperationParameters") {
+            let result = new SampleOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AddComparisonParameters") {
+            let result = new AddComparisonParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "GetModelStateParameters") {
+            let result = new GetModelStateParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FrequentItemsetOperationParameters") {
+            let result = new FrequentItemsetOperationParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'OperationParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["IsCachable"] = this.isCachable;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IOperationParameters extends IUniqueJson {
+    isCachable?: boolean | undefined;
+}
+
+export abstract class DataOperationParameters extends OperationParameters implements IDataOperationParameters {
+    sampleStreamBlockSize?: number | undefined;
+    adapterName?: string | undefined;
+    isCachable?: boolean | undefined;
+
+    constructor(data?: IDataOperationParameters) {
+        super(data);
+        this._discriminator = "DataOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.sampleStreamBlockSize = data["SampleStreamBlockSize"];
+            this.adapterName = data["AdapterName"];
+            this.isCachable = data["IsCachable"];
+        }
+    }
+
+    static fromJS(data: any): DataOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ExampleOperationParameters") {
+            let result = new ExampleOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "HistogramOperationParameters") {
+            let result = new HistogramOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DistOperationParameters") {
+            throw new Error("The abstract class 'DistOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "OptimizerOperationParameters") {
+            let result = new OptimizerOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RawDataOperationParameters") {
+            let result = new RawDataOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RecommenderOperationParameters") {
+            let result = new RecommenderOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CDFOperationParameters") {
+            let result = new CDFOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TestDistOperationParameters") {
+            throw new Error("The abstract class 'TestDistOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "EmpiricalDistOperationParameters") {
+            let result = new EmpiricalDistOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FeatureImportanceOperationParameters") {
+            let result = new FeatureImportanceOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SampleOperationParameters") {
+            let result = new SampleOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FrequentItemsetOperationParameters") {
+            let result = new FrequentItemsetOperationParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'DataOperationParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SampleStreamBlockSize"] = this.sampleStreamBlockSize;
+        data["AdapterName"] = this.adapterName;
+        data["IsCachable"] = this.isCachable;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDataOperationParameters extends IOperationParameters {
+    sampleStreamBlockSize?: number | undefined;
+    adapterName?: string | undefined;
+    isCachable?: boolean | undefined;
+}
+
+export class ExampleOperationParameters extends DataOperationParameters implements IExampleOperationParameters {
+    filter?: string | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    attributeCodeParameters?: AttributeCaclculatedParameters[] | undefined;
+    dummyValue?: number | undefined;
+    exampleType?: string | undefined;
+
+    constructor(data?: IExampleOperationParameters) {
+        super(data);
+        this._discriminator = "ExampleOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.filter = data["Filter"];
+            if (data["AttributeParameters"] && data["AttributeParameters"].constructor === Array) {
+                this.attributeParameters = [];
+                for (let item of data["AttributeParameters"])
+                    this.attributeParameters.push(AttributeParameters.fromJS(item));
+            }
+            if (data["AttributeCodeParameters"] && data["AttributeCodeParameters"].constructor === Array) {
+                this.attributeCodeParameters = [];
+                for (let item of data["AttributeCodeParameters"])
+                    this.attributeCodeParameters.push(AttributeCaclculatedParameters.fromJS(item));
+            }
+            this.dummyValue = data["DummyValue"];
+            this.exampleType = data["ExampleType"];
+        }
+    }
+
+    static fromJS(data: any): ExampleOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new ExampleOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Filter"] = this.filter;
+        if (this.attributeParameters && this.attributeParameters.constructor === Array) {
+            data["AttributeParameters"] = [];
+            for (let item of this.attributeParameters)
+                data["AttributeParameters"].push(item.toJSON());
+        }
+        if (this.attributeCodeParameters && this.attributeCodeParameters.constructor === Array) {
+            data["AttributeCodeParameters"] = [];
+            for (let item of this.attributeCodeParameters)
+                data["AttributeCodeParameters"].push(item.toJSON());
+        }
+        data["DummyValue"] = this.dummyValue;
+        data["ExampleType"] = this.exampleType;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IExampleOperationParameters extends IDataOperationParameters {
+    filter?: string | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    attributeCodeParameters?: AttributeCaclculatedParameters[] | undefined;
+    dummyValue?: number | undefined;
+    exampleType?: string | undefined;
+}
+
+export abstract class DistOperationParameters extends DataOperationParameters implements IDistOperationParameters {
+    filter?: string | undefined;
+    attributeCalculatedParameters?: AttributeCaclculatedParameters[] | undefined;
+
+    constructor(data?: IDistOperationParameters) {
+        super(data);
+        this._discriminator = "DistOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.filter = data["Filter"];
+            if (data["AttributeCalculatedParameters"] && data["AttributeCalculatedParameters"].constructor === Array) {
+                this.attributeCalculatedParameters = [];
+                for (let item of data["AttributeCalculatedParameters"])
+                    this.attributeCalculatedParameters.push(AttributeCaclculatedParameters.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): DistOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "HistogramOperationParameters") {
+            let result = new HistogramOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "OptimizerOperationParameters") {
+            let result = new OptimizerOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RawDataOperationParameters") {
+            let result = new RawDataOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CDFOperationParameters") {
+            let result = new CDFOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TestDistOperationParameters") {
+            throw new Error("The abstract class 'TestDistOperationParameters' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "EmpiricalDistOperationParameters") {
+            let result = new EmpiricalDistOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FeatureImportanceOperationParameters") {
+            let result = new FeatureImportanceOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SampleOperationParameters") {
+            let result = new SampleOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FrequentItemsetOperationParameters") {
+            let result = new FrequentItemsetOperationParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'DistOperationParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Filter"] = this.filter;
+        if (this.attributeCalculatedParameters && this.attributeCalculatedParameters.constructor === Array) {
+            data["AttributeCalculatedParameters"] = [];
+            for (let item of this.attributeCalculatedParameters)
+                data["AttributeCalculatedParameters"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDistOperationParameters extends IDataOperationParameters {
+    filter?: string | undefined;
+    attributeCalculatedParameters?: AttributeCaclculatedParameters[] | undefined;
+}
+
+export class HistogramOperationParameters extends DistOperationParameters implements IHistogramOperationParameters {
+    sortPerBinAggregateParameter?: AggregateParameters | undefined;
+    binningParameters?: BinningParameters[] | undefined;
+    perBinAggregateParameters?: AggregateParameters[] | undefined;
+    globalAggregateParameters?: AggregateParameters[] | undefined;
+    brushes?: string[] | undefined;
+    enableBrushComputation?: boolean | undefined;
+    degreeOfParallism?: number | undefined;
+
+    constructor(data?: IHistogramOperationParameters) {
+        super(data);
+        this._discriminator = "HistogramOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.sortPerBinAggregateParameter = data["SortPerBinAggregateParameter"] ? AggregateParameters.fromJS(data["SortPerBinAggregateParameter"]) : <any>undefined;
+            if (data["BinningParameters"] && data["BinningParameters"].constructor === Array) {
+                this.binningParameters = [];
+                for (let item of data["BinningParameters"])
+                    this.binningParameters.push(BinningParameters.fromJS(item));
+            }
+            if (data["PerBinAggregateParameters"] && data["PerBinAggregateParameters"].constructor === Array) {
+                this.perBinAggregateParameters = [];
+                for (let item of data["PerBinAggregateParameters"])
+                    this.perBinAggregateParameters.push(AggregateParameters.fromJS(item));
+            }
+            if (data["GlobalAggregateParameters"] && data["GlobalAggregateParameters"].constructor === Array) {
+                this.globalAggregateParameters = [];
+                for (let item of data["GlobalAggregateParameters"])
+                    this.globalAggregateParameters.push(AggregateParameters.fromJS(item));
+            }
+            if (data["Brushes"] && data["Brushes"].constructor === Array) {
+                this.brushes = [];
+                for (let item of data["Brushes"])
+                    this.brushes.push(item);
+            }
+            this.enableBrushComputation = data["EnableBrushComputation"];
+            this.degreeOfParallism = data["DegreeOfParallism"];
+        }
+    }
+
+    static fromJS(data: any): HistogramOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new HistogramOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SortPerBinAggregateParameter"] = this.sortPerBinAggregateParameter ? this.sortPerBinAggregateParameter.toJSON() : <any>undefined;
+        if (this.binningParameters && this.binningParameters.constructor === Array) {
+            data["BinningParameters"] = [];
+            for (let item of this.binningParameters)
+                data["BinningParameters"].push(item.toJSON());
+        }
+        if (this.perBinAggregateParameters && this.perBinAggregateParameters.constructor === Array) {
+            data["PerBinAggregateParameters"] = [];
+            for (let item of this.perBinAggregateParameters)
+                data["PerBinAggregateParameters"].push(item.toJSON());
+        }
+        if (this.globalAggregateParameters && this.globalAggregateParameters.constructor === Array) {
+            data["GlobalAggregateParameters"] = [];
+            for (let item of this.globalAggregateParameters)
+                data["GlobalAggregateParameters"].push(item.toJSON());
+        }
+        if (this.brushes && this.brushes.constructor === Array) {
+            data["Brushes"] = [];
+            for (let item of this.brushes)
+                data["Brushes"].push(item);
+        }
+        data["EnableBrushComputation"] = this.enableBrushComputation;
+        data["DegreeOfParallism"] = this.degreeOfParallism;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IHistogramOperationParameters extends IDistOperationParameters {
+    sortPerBinAggregateParameter?: AggregateParameters | undefined;
+    binningParameters?: BinningParameters[] | undefined;
+    perBinAggregateParameters?: AggregateParameters[] | undefined;
+    globalAggregateParameters?: AggregateParameters[] | undefined;
+    brushes?: string[] | undefined;
+    enableBrushComputation?: boolean | undefined;
+    degreeOfParallism?: number | undefined;
+}
+
+export class OptimizerOperationParameters extends DistOperationParameters implements IOptimizerOperationParameters {
+    taskType?: TaskType | undefined;
+    taskSubType?: TaskSubType | undefined;
+    metricType?: MetricType | undefined;
+    labelAttribute?: AttributeParameters | undefined;
+    featureAttributes?: AttributeParameters[] | undefined;
+    requiredPrimitives?: string[] | undefined;
+    pythonFilter?: string | undefined;
+    trainFilter?: string | undefined;
+    pythonTrainFilter?: string | undefined;
+    testFilter?: string | undefined;
+    pythonTestFilter?: string | undefined;
+
+    constructor(data?: IOptimizerOperationParameters) {
+        super(data);
+        this._discriminator = "OptimizerOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.taskType = data["TaskType"];
+            this.taskSubType = data["TaskSubType"];
+            this.metricType = data["MetricType"];
+            this.labelAttribute = data["LabelAttribute"] ? AttributeParameters.fromJS(data["LabelAttribute"]) : <any>undefined;
+            if (data["FeatureAttributes"] && data["FeatureAttributes"].constructor === Array) {
+                this.featureAttributes = [];
+                for (let item of data["FeatureAttributes"])
+                    this.featureAttributes.push(AttributeParameters.fromJS(item));
+            }
+            if (data["RequiredPrimitives"] && data["RequiredPrimitives"].constructor === Array) {
+                this.requiredPrimitives = [];
+                for (let item of data["RequiredPrimitives"])
+                    this.requiredPrimitives.push(item);
+            }
+            this.pythonFilter = data["PythonFilter"];
+            this.trainFilter = data["TrainFilter"];
+            this.pythonTrainFilter = data["PythonTrainFilter"];
+            this.testFilter = data["TestFilter"];
+            this.pythonTestFilter = data["PythonTestFilter"];
+        }
+    }
+
+    static fromJS(data: any): OptimizerOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new OptimizerOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["TaskType"] = this.taskType;
+        data["TaskSubType"] = this.taskSubType;
+        data["MetricType"] = this.metricType;
+        data["LabelAttribute"] = this.labelAttribute ? this.labelAttribute.toJSON() : <any>undefined;
+        if (this.featureAttributes && this.featureAttributes.constructor === Array) {
+            data["FeatureAttributes"] = [];
+            for (let item of this.featureAttributes)
+                data["FeatureAttributes"].push(item.toJSON());
+        }
+        if (this.requiredPrimitives && this.requiredPrimitives.constructor === Array) {
+            data["RequiredPrimitives"] = [];
+            for (let item of this.requiredPrimitives)
+                data["RequiredPrimitives"].push(item);
+        }
+        data["PythonFilter"] = this.pythonFilter;
+        data["TrainFilter"] = this.trainFilter;
+        data["PythonTrainFilter"] = this.pythonTrainFilter;
+        data["TestFilter"] = this.testFilter;
+        data["PythonTestFilter"] = this.pythonTestFilter;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IOptimizerOperationParameters extends IDistOperationParameters {
+    taskType?: TaskType | undefined;
+    taskSubType?: TaskSubType | undefined;
+    metricType?: MetricType | undefined;
+    labelAttribute?: AttributeParameters | undefined;
+    featureAttributes?: AttributeParameters[] | undefined;
+    requiredPrimitives?: string[] | undefined;
+    pythonFilter?: string | undefined;
+    trainFilter?: string | undefined;
+    pythonTrainFilter?: string | undefined;
+    testFilter?: string | undefined;
+    pythonTestFilter?: string | undefined;
+}
+
+export enum TaskType {
+    Undefined = 0,
+    Classification = 1,
+    Regression = 2,
+    Clustering = 3,
+    LinkPrediction = 4,
+    VertexNomination = 5,
+    CommunityDetection = 6,
+    GraphClustering = 7,
+    GraphMatching = 8,
+    TimeSeriesForecasting = 9,
+    CollaborativeFiltering = 10,
+}
+
+export enum TaskSubType {
+    Undefined = 0,
+    None = 1,
+    Binary = 2,
+    Multiclass = 3,
+    Multilabel = 4,
+    Univariate = 5,
+    Multivariate = 6,
+    Overlapping = 7,
+    Nonoverlapping = 8,
+}
+
+export enum MetricType {
+    MetricUndefined = 0,
+    Accuracy = 1,
+    Precision = 2,
+    Recall = 3,
+    F1 = 4,
+    F1Micro = 5,
+    F1Macro = 6,
+    RocAuc = 7,
+    RocAucMicro = 8,
+    RocAucMacro = 9,
+    MeanSquaredError = 10,
+    RootMeanSquaredError = 11,
+    RootMeanSquaredErrorAvg = 12,
+    MeanAbsoluteError = 13,
+    RSquared = 14,
+    NormalizedMutualInformation = 15,
+    JaccardSimilarityScore = 16,
+    PrecisionAtTopK = 17,
+    ObjectDetectionAveragePrecision = 18,
+    Loss = 100,
+}
+
+export class RawDataOperationParameters extends DistOperationParameters implements IRawDataOperationParameters {
+    sortUpRawName?: string | undefined;
+    sortDownRawName?: string | undefined;
+    numRecords?: number | undefined;
+    binningParameters?: BinningParameters[] | undefined;
+    brushes?: string[] | undefined;
+    enableBrushComputation?: boolean | undefined;
+
+    constructor(data?: IRawDataOperationParameters) {
+        super(data);
+        this._discriminator = "RawDataOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.sortUpRawName = data["SortUpRawName"];
+            this.sortDownRawName = data["SortDownRawName"];
+            this.numRecords = data["NumRecords"];
+            if (data["BinningParameters"] && data["BinningParameters"].constructor === Array) {
+                this.binningParameters = [];
+                for (let item of data["BinningParameters"])
+                    this.binningParameters.push(BinningParameters.fromJS(item));
+            }
+            if (data["Brushes"] && data["Brushes"].constructor === Array) {
+                this.brushes = [];
+                for (let item of data["Brushes"])
+                    this.brushes.push(item);
+            }
+            this.enableBrushComputation = data["EnableBrushComputation"];
+        }
+    }
+
+    static fromJS(data: any): RawDataOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new RawDataOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SortUpRawName"] = this.sortUpRawName;
+        data["SortDownRawName"] = this.sortDownRawName;
+        data["NumRecords"] = this.numRecords;
+        if (this.binningParameters && this.binningParameters.constructor === Array) {
+            data["BinningParameters"] = [];
+            for (let item of this.binningParameters)
+                data["BinningParameters"].push(item.toJSON());
+        }
+        if (this.brushes && this.brushes.constructor === Array) {
+            data["Brushes"] = [];
+            for (let item of this.brushes)
+                data["Brushes"].push(item);
+        }
+        data["EnableBrushComputation"] = this.enableBrushComputation;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRawDataOperationParameters extends IDistOperationParameters {
+    sortUpRawName?: string | undefined;
+    sortDownRawName?: string | undefined;
+    numRecords?: number | undefined;
+    binningParameters?: BinningParameters[] | undefined;
+    brushes?: string[] | undefined;
+    enableBrushComputation?: boolean | undefined;
+}
+
+export class RecommenderOperationParameters extends DataOperationParameters implements IRecommenderOperationParameters {
+    target?: HistogramOperationParameters | undefined;
+    budget?: number | undefined;
+    modelId?: ModelId | undefined;
+    includeAttributeParameters?: AttributeParameters[] | undefined;
+    excludeAttributeParameters?: AttributeParameters[] | undefined;
+    riskControlType?: RiskControlType | undefined;
+
+    constructor(data?: IRecommenderOperationParameters) {
+        super(data);
+        this._discriminator = "RecommenderOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.target = data["Target"] ? HistogramOperationParameters.fromJS(data["Target"]) : <any>undefined;
+            this.budget = data["Budget"];
+            this.modelId = data["ModelId"] ? ModelId.fromJS(data["ModelId"]) : <any>undefined;
+            if (data["IncludeAttributeParameters"] && data["IncludeAttributeParameters"].constructor === Array) {
+                this.includeAttributeParameters = [];
+                for (let item of data["IncludeAttributeParameters"])
+                    this.includeAttributeParameters.push(AttributeParameters.fromJS(item));
+            }
+            if (data["ExcludeAttributeParameters"] && data["ExcludeAttributeParameters"].constructor === Array) {
+                this.excludeAttributeParameters = [];
+                for (let item of data["ExcludeAttributeParameters"])
+                    this.excludeAttributeParameters.push(AttributeParameters.fromJS(item));
+            }
+            this.riskControlType = data["RiskControlType"];
+        }
+    }
+
+    static fromJS(data: any): RecommenderOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new RecommenderOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Target"] = this.target ? this.target.toJSON() : <any>undefined;
+        data["Budget"] = this.budget;
+        data["ModelId"] = this.modelId ? this.modelId.toJSON() : <any>undefined;
+        if (this.includeAttributeParameters && this.includeAttributeParameters.constructor === Array) {
+            data["IncludeAttributeParameters"] = [];
+            for (let item of this.includeAttributeParameters)
+                data["IncludeAttributeParameters"].push(item.toJSON());
+        }
+        if (this.excludeAttributeParameters && this.excludeAttributeParameters.constructor === Array) {
+            data["ExcludeAttributeParameters"] = [];
+            for (let item of this.excludeAttributeParameters)
+                data["ExcludeAttributeParameters"].push(item.toJSON());
+        }
+        data["RiskControlType"] = this.riskControlType;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRecommenderOperationParameters extends IDataOperationParameters {
+    target?: HistogramOperationParameters | undefined;
+    budget?: number | undefined;
+    modelId?: ModelId | undefined;
+    includeAttributeParameters?: AttributeParameters[] | undefined;
+    excludeAttributeParameters?: AttributeParameters[] | undefined;
+    riskControlType?: RiskControlType | undefined;
+}
+
+export class ModelId implements IModelId {
+    value?: string | undefined;
+
+    constructor(data?: IModelId) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): ModelId {
+        data = typeof data === 'object' ? data : {};
+        let result = new ModelId();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        return data;
+    }
+}
+
+export interface IModelId {
+    value?: string | undefined;
+}
+
+export enum RiskControlType {
+    PCER = 0,
+    Bonferroni = 1,
+    AdaBonferroni = 2,
+    HolmBonferroni = 3,
+    BHFDR = 4,
+    SeqFDR = 5,
+    AlphaFDR = 6,
+    BestFootForward = 7,
+    BetaFarsighted = 8,
+    BetaFarsightedWithSupport = 9,
+    GammaFixed = 10,
+    DeltaHopeful = 11,
+    EpsilonHybrid = 12,
+    EpsilonHybridWithoutSupport = 13,
+    PsiSupport = 14,
+    ZetaDynamic = 15,
+    Unknown = 16,
+}
+
+export abstract class TestDistOperationParameters extends DistOperationParameters implements ITestDistOperationParameters {
+    attributeParameters?: AttributeParameters[] | undefined;
+
+    constructor(data?: ITestDistOperationParameters) {
+        super(data);
+        this._discriminator = "TestDistOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["AttributeParameters"] && data["AttributeParameters"].constructor === Array) {
+                this.attributeParameters = [];
+                for (let item of data["AttributeParameters"])
+                    this.attributeParameters.push(AttributeParameters.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): TestDistOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "CDFOperationParameters") {
+            let result = new CDFOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "EmpiricalDistOperationParameters") {
+            let result = new EmpiricalDistOperationParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'TestDistOperationParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.attributeParameters && this.attributeParameters.constructor === Array) {
+            data["AttributeParameters"] = [];
+            for (let item of this.attributeParameters)
+                data["AttributeParameters"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ITestDistOperationParameters extends IDistOperationParameters {
+    attributeParameters?: AttributeParameters[] | undefined;
+}
+
+export class CDFOperationParameters extends TestDistOperationParameters implements ICDFOperationParameters {
+
+    constructor(data?: ICDFOperationParameters) {
+        super(data);
+        this._discriminator = "CDFOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): CDFOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new CDFOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICDFOperationParameters extends ITestDistOperationParameters {
+}
+
+export abstract class HypothesisTestParameters extends OperationParameters implements IHypothesisTestParameters {
+    childOperationParameters?: OperationParameters[] | undefined;
+    isCachable?: boolean | undefined;
+
+    constructor(data?: IHypothesisTestParameters) {
+        super(data);
+        this._discriminator = "HypothesisTestParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["ChildOperationParameters"] && data["ChildOperationParameters"].constructor === Array) {
+                this.childOperationParameters = [];
+                for (let item of data["ChildOperationParameters"])
+                    this.childOperationParameters.push(OperationParameters.fromJS(item));
+            }
+            this.isCachable = data["IsCachable"];
+        }
+    }
+
+    static fromJS(data: any): HypothesisTestParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ChiSquaredTestOperationParameters") {
+            let result = new ChiSquaredTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CorrelationTestOperationParameters") {
+            let result = new CorrelationTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KSTestOperationParameters") {
+            let result = new KSTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RootMeanSquareTestOperationParameters") {
+            let result = new RootMeanSquareTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TTestOperationParameters") {
+            let result = new TTestOperationParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'HypothesisTestParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.childOperationParameters && this.childOperationParameters.constructor === Array) {
+            data["ChildOperationParameters"] = [];
+            for (let item of this.childOperationParameters)
+                data["ChildOperationParameters"].push(item.toJSON());
+        }
+        data["IsCachable"] = this.isCachable;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IHypothesisTestParameters extends IOperationParameters {
+    childOperationParameters?: OperationParameters[] | undefined;
+    isCachable?: boolean | undefined;
+}
+
+export class ChiSquaredTestOperationParameters extends HypothesisTestParameters implements IChiSquaredTestOperationParameters {
+
+    constructor(data?: IChiSquaredTestOperationParameters) {
+        super(data);
+        this._discriminator = "ChiSquaredTestOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): ChiSquaredTestOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new ChiSquaredTestOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IChiSquaredTestOperationParameters extends IHypothesisTestParameters {
+}
+
+export class CorrelationTestOperationParameters extends HypothesisTestParameters implements ICorrelationTestOperationParameters {
+
+    constructor(data?: ICorrelationTestOperationParameters) {
+        super(data);
+        this._discriminator = "CorrelationTestOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): CorrelationTestOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new CorrelationTestOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICorrelationTestOperationParameters extends IHypothesisTestParameters {
+}
+
+export class SubmitProblemParameters implements ISubmitProblemParameters {
+    id?: string | undefined;
+
+    constructor(data?: ISubmitProblemParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+        }
+    }
+
+    static fromJS(data: any): SubmitProblemParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SubmitProblemParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        return data;
+    }
+}
+
+export interface ISubmitProblemParameters {
+    id?: string | undefined;
+}
+
+export class SpecifyProblemParameters implements ISpecifyProblemParameters {
+    id?: string | undefined;
+    userComment?: string | undefined;
+    optimizerOperationParameters?: OptimizerOperationParameters | undefined;
+
+    constructor(data?: ISpecifyProblemParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+            this.userComment = data["UserComment"];
+            this.optimizerOperationParameters = data["OptimizerOperationParameters"] ? OptimizerOperationParameters.fromJS(data["OptimizerOperationParameters"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): SpecifyProblemParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SpecifyProblemParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        data["UserComment"] = this.userComment;
+        data["OptimizerOperationParameters"] = this.optimizerOperationParameters ? this.optimizerOperationParameters.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface ISpecifyProblemParameters {
+    id?: string | undefined;
+    userComment?: string | undefined;
+    optimizerOperationParameters?: OptimizerOperationParameters | undefined;
+}
+
+export class EmpiricalDistOperationParameters extends TestDistOperationParameters implements IEmpiricalDistOperationParameters {
+    keepSamples?: boolean | undefined;
+
+    constructor(data?: IEmpiricalDistOperationParameters) {
+        super(data);
+        this._discriminator = "EmpiricalDistOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.keepSamples = data["KeepSamples"];
+        }
+    }
+
+    static fromJS(data: any): EmpiricalDistOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new EmpiricalDistOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["KeepSamples"] = this.keepSamples;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IEmpiricalDistOperationParameters extends ITestDistOperationParameters {
+    keepSamples?: boolean | undefined;
+}
+
+export class KSTestOperationParameters extends HypothesisTestParameters implements IKSTestOperationParameters {
+
+    constructor(data?: IKSTestOperationParameters) {
+        super(data);
+        this._discriminator = "KSTestOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): KSTestOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new KSTestOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IKSTestOperationParameters extends IHypothesisTestParameters {
+}
+
+export abstract class ModelOperationParameters extends OperationParameters implements IModelOperationParameters {
+
+    constructor(data?: IModelOperationParameters) {
+        super(data);
+        this._discriminator = "ModelOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): ModelOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "NewModelOperationParameters") {
+            let result = new NewModelOperationParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AddComparisonParameters") {
+            let result = new AddComparisonParameters();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "GetModelStateParameters") {
+            let result = new GetModelStateParameters();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'ModelOperationParameters' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IModelOperationParameters extends IOperationParameters {
+}
+
+export class NewModelOperationParameters extends ModelOperationParameters implements INewModelOperationParameters {
+    riskControlTypes?: RiskControlType[] | undefined;
+    alpha?: number | undefined;
+    alphaInvestParameter?: AlphaInvestParameter | undefined;
+
+    constructor(data?: INewModelOperationParameters) {
+        super(data);
+        this._discriminator = "NewModelOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["RiskControlTypes"] && data["RiskControlTypes"].constructor === Array) {
+                this.riskControlTypes = [];
+                for (let item of data["RiskControlTypes"])
+                    this.riskControlTypes.push(item);
+            }
+            this.alpha = data["Alpha"];
+            this.alphaInvestParameter = data["AlphaInvestParameter"] ? AlphaInvestParameter.fromJS(data["AlphaInvestParameter"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): NewModelOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new NewModelOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.riskControlTypes && this.riskControlTypes.constructor === Array) {
+            data["RiskControlTypes"] = [];
+            for (let item of this.riskControlTypes)
+                data["RiskControlTypes"].push(item);
+        }
+        data["Alpha"] = this.alpha;
+        data["AlphaInvestParameter"] = this.alphaInvestParameter ? this.alphaInvestParameter.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface INewModelOperationParameters extends IModelOperationParameters {
+    riskControlTypes?: RiskControlType[] | undefined;
+    alpha?: number | undefined;
+    alphaInvestParameter?: AlphaInvestParameter | undefined;
+}
+
+export class AlphaInvestParameter extends UniqueJson implements IAlphaInvestParameter {
+    beta?: number | undefined;
+    gamma?: number | undefined;
+    delta?: number | undefined;
+    epsilon?: number | undefined;
+    windowSize?: number | undefined;
+    psi?: number | undefined;
+
+    constructor(data?: IAlphaInvestParameter) {
+        super(data);
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.beta = data["Beta"];
+            this.gamma = data["Gamma"];
+            this.delta = data["Delta"];
+            this.epsilon = data["Epsilon"];
+            this.windowSize = data["WindowSize"];
+            this.psi = data["Psi"];
+        }
+    }
+
+    static fromJS(data: any): AlphaInvestParameter {
+        data = typeof data === 'object' ? data : {};
+        let result = new AlphaInvestParameter();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Beta"] = this.beta;
+        data["Gamma"] = this.gamma;
+        data["Delta"] = this.delta;
+        data["Epsilon"] = this.epsilon;
+        data["WindowSize"] = this.windowSize;
+        data["Psi"] = this.psi;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAlphaInvestParameter extends IUniqueJson {
+    beta?: number | undefined;
+    gamma?: number | undefined;
+    delta?: number | undefined;
+    epsilon?: number | undefined;
+    windowSize?: number | undefined;
+    psi?: number | undefined;
+}
+
+export class RootMeanSquareTestOperationParameters extends HypothesisTestParameters implements IRootMeanSquareTestOperationParameters {
+    seeded?: boolean | undefined;
+    pValueConvergenceThreshold?: number | undefined;
+    maxSimulationBatchCount?: number | undefined;
+    perBatchSimulationCount?: number | undefined;
+
+    constructor(data?: IRootMeanSquareTestOperationParameters) {
+        super(data);
+        this._discriminator = "RootMeanSquareTestOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.seeded = data["Seeded"];
+            this.pValueConvergenceThreshold = data["PValueConvergenceThreshold"];
+            this.maxSimulationBatchCount = data["MaxSimulationBatchCount"];
+            this.perBatchSimulationCount = data["PerBatchSimulationCount"];
+        }
+    }
+
+    static fromJS(data: any): RootMeanSquareTestOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new RootMeanSquareTestOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Seeded"] = this.seeded;
+        data["PValueConvergenceThreshold"] = this.pValueConvergenceThreshold;
+        data["MaxSimulationBatchCount"] = this.maxSimulationBatchCount;
+        data["PerBatchSimulationCount"] = this.perBatchSimulationCount;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRootMeanSquareTestOperationParameters extends IHypothesisTestParameters {
+    seeded?: boolean | undefined;
+    pValueConvergenceThreshold?: number | undefined;
+    maxSimulationBatchCount?: number | undefined;
+    perBatchSimulationCount?: number | undefined;
+}
+
+export class TTestOperationParameters extends HypothesisTestParameters implements ITTestOperationParameters {
+
+    constructor(data?: ITTestOperationParameters) {
+        super(data);
+        this._discriminator = "TTestOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): TTestOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new TTestOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ITTestOperationParameters extends IHypothesisTestParameters {
+}
+
+export enum EffectSize {
+    Small = 1,
+    Meduim = 2,
+    Large = 4,
+}
+
+export abstract class Result extends UniqueJson implements IResult {
+    progress?: number | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IResult) {
+        super(data);
+        this._discriminator = "Result";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.progress = data["Progress"];
+        }
+    }
+
+    static fromJS(data: any): Result {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ErrorResult") {
+            let result = new ErrorResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "HistogramResult") {
+            let result = new HistogramResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DistResult") {
+            throw new Error("The abstract class 'DistResult' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "ModelWealthResult") {
+            let result = new ModelWealthResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "HypothesisTestResult") {
+            throw new Error("The abstract class 'HypothesisTestResult' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "ModelOperationResult") {
+            throw new Error("The abstract class 'ModelOperationResult' cannot be instantiated.");
+        }
+        if (data["discriminator"] === "RecommenderResult") {
+            let result = new RecommenderResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "Decision") {
+            let result = new Decision();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "OptimizerResult") {
+            let result = new OptimizerResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ExampleResult") {
+            let result = new ExampleResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "NewModelOperationResult") {
+            let result = new NewModelOperationResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AddComparisonResult") {
+            let result = new AddComparisonResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "GetModelStateResult") {
+            let result = new GetModelStateResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FeatureImportanceResult") {
+            let result = new FeatureImportanceResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RawDataResult") {
+            let result = new RawDataResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SampleResult") {
+            let result = new SampleResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CDFResult") {
+            let result = new CDFResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ChiSquaredTestResult") {
+            let result = new ChiSquaredTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CorrelationTestResult") {
+            let result = new CorrelationTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "EmpiricalDistResult") {
+            let result = new EmpiricalDistResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KSTestResult") {
+            let result = new KSTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RootMeanSquareTestResult") {
+            let result = new RootMeanSquareTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TTestResult") {
+            let result = new TTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "FrequentItemsetResult") {
+            let result = new FrequentItemsetResult();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'Result' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["Progress"] = this.progress;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IResult extends IUniqueJson {
+    progress?: number | undefined;
+}
+
+export class ErrorResult extends Result implements IErrorResult {
+    message?: string | undefined;
+
+    constructor(data?: IErrorResult) {
+        super(data);
+        this._discriminator = "ErrorResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.message = data["Message"];
+        }
+    }
+
+    static fromJS(data: any): ErrorResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new ErrorResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Message"] = this.message;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IErrorResult extends IResult {
+    message?: string | undefined;
+}
+
+export abstract class DistResult extends Result implements IDistResult {
+    sampleSize?: number | undefined;
+    populationSize?: number | undefined;
+
+    constructor(data?: IDistResult) {
+        super(data);
+        this._discriminator = "DistResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.sampleSize = data["SampleSize"];
+            this.populationSize = data["PopulationSize"];
+        }
+    }
+
+    static fromJS(data: any): DistResult {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "HistogramResult") {
+            let result = new HistogramResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RawDataResult") {
+            let result = new RawDataResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SampleResult") {
+            let result = new SampleResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CDFResult") {
+            let result = new CDFResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "EmpiricalDistResult") {
+            let result = new EmpiricalDistResult();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'DistResult' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SampleSize"] = this.sampleSize;
+        data["PopulationSize"] = this.populationSize;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDistResult extends IResult {
+    sampleSize?: number | undefined;
+    populationSize?: number | undefined;
+}
+
+export class HistogramResult extends DistResult implements IHistogramResult {
+    aggregateResults?: AggregateResult[][] | undefined;
+    isEmpty?: boolean | undefined;
+    brushes?: Brush[] | undefined;
+    binRanges?: BinRange[] | undefined;
+    aggregateParameters?: AggregateParameters[] | undefined;
+    nullValueCount?: number | undefined;
+    bins?: { [key: string]: Bin; } | undefined;
+
+    constructor(data?: IHistogramResult) {
+        super(data);
+        this._discriminator = "HistogramResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["AggregateResults"] && data["AggregateResults"].constructor === Array) {
+                this.aggregateResults = [];
+                for (let item of data["AggregateResults"])
+                    this.aggregateResults.push(item);
+            }
+            this.isEmpty = data["IsEmpty"];
+            if (data["Brushes"] && data["Brushes"].constructor === Array) {
+                this.brushes = [];
+                for (let item of data["Brushes"])
+                    this.brushes.push(Brush.fromJS(item));
+            }
+            if (data["BinRanges"] && data["BinRanges"].constructor === Array) {
+                this.binRanges = [];
+                for (let item of data["BinRanges"])
+                    this.binRanges.push(BinRange.fromJS(item));
+            }
+            if (data["AggregateParameters"] && data["AggregateParameters"].constructor === Array) {
+                this.aggregateParameters = [];
+                for (let item of data["AggregateParameters"])
+                    this.aggregateParameters.push(AggregateParameters.fromJS(item));
+            }
+            this.nullValueCount = data["NullValueCount"];
+            if (data["Bins"]) {
+                this.bins = {};
+                for (let key in data["Bins"]) {
+                    if (data["Bins"].hasOwnProperty(key))
+                        this.bins[key] = data["Bins"][key] ? Bin.fromJS(data["Bins"][key]) : new Bin();
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): HistogramResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new HistogramResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.aggregateResults && this.aggregateResults.constructor === Array) {
+            data["AggregateResults"] = [];
+            for (let item of this.aggregateResults)
+                data["AggregateResults"].push(item);
+        }
+        data["IsEmpty"] = this.isEmpty;
+        if (this.brushes && this.brushes.constructor === Array) {
+            data["Brushes"] = [];
+            for (let item of this.brushes)
+                data["Brushes"].push(item.toJSON());
+        }
+        if (this.binRanges && this.binRanges.constructor === Array) {
+            data["BinRanges"] = [];
+            for (let item of this.binRanges)
+                data["BinRanges"].push(item.toJSON());
+        }
+        if (this.aggregateParameters && this.aggregateParameters.constructor === Array) {
+            data["AggregateParameters"] = [];
+            for (let item of this.aggregateParameters)
+                data["AggregateParameters"].push(item.toJSON());
+        }
+        data["NullValueCount"] = this.nullValueCount;
+        if (this.bins) {
+            data["Bins"] = {};
+            for (let key in this.bins) {
+                if (this.bins.hasOwnProperty(key))
+                    data["Bins"][key] = this.bins[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IHistogramResult extends IDistResult {
+    aggregateResults?: AggregateResult[][] | undefined;
+    isEmpty?: boolean | undefined;
+    brushes?: Brush[] | undefined;
+    binRanges?: BinRange[] | undefined;
+    aggregateParameters?: AggregateParameters[] | undefined;
+    nullValueCount?: number | undefined;
+    bins?: { [key: string]: Bin; } | undefined;
+}
+
+export abstract class AggregateResult implements IAggregateResult {
+    hasResult?: boolean | undefined;
+    n?: number | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IAggregateResult) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "AggregateResult";
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.hasResult = data["HasResult"];
+            this.n = data["N"];
+        }
+    }
+
+    static fromJS(data: any): AggregateResult | undefined {
+        if (data === null || data === undefined) {
+            return undefined;
+        }
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "MarginAggregateResult") {
+            let result = new MarginAggregateResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DoubleValueAggregateResult") {
+            let result = new DoubleValueAggregateResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PointsAggregateResult") {
+            let result = new PointsAggregateResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SumEstimationAggregateResult") {
+            let result = new SumEstimationAggregateResult();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'AggregateResult' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["HasResult"] = this.hasResult;
+        data["N"] = this.n;
+        return data;
+    }
+}
+
+export interface IAggregateResult {
+    hasResult?: boolean | undefined;
+    n?: number | undefined;
+}
+
+export class MarginAggregateResult extends AggregateResult implements IMarginAggregateResult {
+    margin?: number | undefined;
+    absolutMargin?: number | undefined;
+    sumOfSquare?: number | undefined;
+    sampleStandardDeviation?: number | undefined;
+    mean?: number | undefined;
+    ex?: number | undefined;
+    ex2?: number | undefined;
+    variance?: number | undefined;
+
+    constructor(data?: IMarginAggregateResult) {
+        super(data);
+        this._discriminator = "MarginAggregateResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.margin = data["Margin"];
+            this.absolutMargin = data["AbsolutMargin"];
+            this.sumOfSquare = data["SumOfSquare"];
+            this.sampleStandardDeviation = data["SampleStandardDeviation"];
+            this.mean = data["Mean"];
+            this.ex = data["Ex"];
+            this.ex2 = data["Ex2"];
+            this.variance = data["Variance"];
+        }
+    }
+
+    static fromJS(data: any): MarginAggregateResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new MarginAggregateResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Margin"] = this.margin;
+        data["AbsolutMargin"] = this.absolutMargin;
+        data["SumOfSquare"] = this.sumOfSquare;
+        data["SampleStandardDeviation"] = this.sampleStandardDeviation;
+        data["Mean"] = this.mean;
+        data["Ex"] = this.ex;
+        data["Ex2"] = this.ex2;
+        data["Variance"] = this.variance;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IMarginAggregateResult extends IAggregateResult {
+    margin?: number | undefined;
+    absolutMargin?: number | undefined;
+    sumOfSquare?: number | undefined;
+    sampleStandardDeviation?: number | undefined;
+    mean?: number | undefined;
+    ex?: number | undefined;
+    ex2?: number | undefined;
+    variance?: number | undefined;
+}
+
+export class DoubleValueAggregateResult extends AggregateResult implements IDoubleValueAggregateResult {
+    result?: number | undefined;
+    temporaryResult?: number | undefined;
+
+    constructor(data?: IDoubleValueAggregateResult) {
+        super(data);
+        this._discriminator = "DoubleValueAggregateResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.result = data["Result"];
+            this.temporaryResult = data["TemporaryResult"];
+        }
+    }
+
+    static fromJS(data: any): DoubleValueAggregateResult {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "SumEstimationAggregateResult") {
+            let result = new SumEstimationAggregateResult();
+            result.init(data);
+            return result;
+        }
+        let result = new DoubleValueAggregateResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Result"] = this.result;
+        data["TemporaryResult"] = this.temporaryResult;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDoubleValueAggregateResult extends IAggregateResult {
+    result?: number | undefined;
+    temporaryResult?: number | undefined;
+}
+
+export class PointsAggregateResult extends AggregateResult implements IPointsAggregateResult {
+    points?: Point[] | undefined;
+
+    constructor(data?: IPointsAggregateResult) {
+        super(data);
+        this._discriminator = "PointsAggregateResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Points"] && data["Points"].constructor === Array) {
+                this.points = [];
+                for (let item of data["Points"])
+                    this.points.push(Point.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): PointsAggregateResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new PointsAggregateResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.points && this.points.constructor === Array) {
+            data["Points"] = [];
+            for (let item of this.points)
+                data["Points"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPointsAggregateResult extends IAggregateResult {
+    points?: Point[] | undefined;
+}
+
+export class Point implements IPoint {
+    x?: number | undefined;
+    y?: number | undefined;
+
+    constructor(data?: IPoint) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.x = data["X"];
+            this.y = data["Y"];
+        }
+    }
+
+    static fromJS(data: any): Point {
+        data = typeof data === 'object' ? data : {};
+        let result = new Point();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["X"] = this.x;
+        data["Y"] = this.y;
+        return data;
+    }
+}
+
+export interface IPoint {
+    x?: number | undefined;
+    y?: number | undefined;
+}
+
+export class SumEstimationAggregateResult extends DoubleValueAggregateResult implements ISumEstimationAggregateResult {
+    sum?: number | undefined;
+    sumEstimation?: number | undefined;
+
+    constructor(data?: ISumEstimationAggregateResult) {
+        super(data);
+        this._discriminator = "SumEstimationAggregateResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.sum = data["Sum"];
+            this.sumEstimation = data["SumEstimation"];
+        }
+    }
+
+    static fromJS(data: any): SumEstimationAggregateResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new SumEstimationAggregateResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Sum"] = this.sum;
+        data["SumEstimation"] = this.sumEstimation;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISumEstimationAggregateResult extends IDoubleValueAggregateResult {
+    sum?: number | undefined;
+    sumEstimation?: number | undefined;
+}
+
+export class Brush implements IBrush {
+    brushIndex?: number | undefined;
+    brushEnum?: BrushEnum | undefined;
+
+    constructor(data?: IBrush) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.brushIndex = data["BrushIndex"];
+            this.brushEnum = data["BrushEnum"];
+        }
+    }
+
+    static fromJS(data: any): Brush {
+        data = typeof data === 'object' ? data : {};
+        let result = new Brush();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["BrushIndex"] = this.brushIndex;
+        data["BrushEnum"] = this.brushEnum;
+        return data;
+    }
+}
+
+export interface IBrush {
+    brushIndex?: number | undefined;
+    brushEnum?: BrushEnum | undefined;
+}
+
+export enum BrushEnum {
+    Overlap = 0,
+    Rest = 1,
+    All = 2,
+    UserSpecified = 3,
+}
+
+export abstract class BinRange implements IBinRange {
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    targetBinNumber?: number | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IBinRange) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "BinRange";
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.minValue = data["MinValue"];
+            this.maxValue = data["MaxValue"];
+            this.targetBinNumber = data["TargetBinNumber"];
+        }
+    }
+
+    static fromJS(data: any): BinRange {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "NominalBinRange") {
+            let result = new NominalBinRange();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "QuantitativeBinRange") {
+            let result = new QuantitativeBinRange();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AggregateBinRange") {
+            let result = new AggregateBinRange();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AlphabeticBinRange") {
+            let result = new AlphabeticBinRange();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DateTimeBinRange") {
+            let result = new DateTimeBinRange();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'BinRange' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["MinValue"] = this.minValue;
+        data["MaxValue"] = this.maxValue;
+        data["TargetBinNumber"] = this.targetBinNumber;
+        return data;
+    }
+}
+
+export interface IBinRange {
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    targetBinNumber?: number | undefined;
+}
+
+export class NominalBinRange extends BinRange implements INominalBinRange {
+    labelsValue?: { [key: string]: number; } | undefined;
+    valuesLabel?: { [key: string]: string; } | undefined;
+
+    constructor(data?: INominalBinRange) {
+        super(data);
+        this._discriminator = "NominalBinRange";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["LabelsValue"]) {
+                this.labelsValue = {};
+                for (let key in data["LabelsValue"]) {
+                    if (data["LabelsValue"].hasOwnProperty(key))
+                        this.labelsValue[key] = data["LabelsValue"][key];
+                }
+            }
+            if (data["ValuesLabel"]) {
+                this.valuesLabel = {};
+                for (let key in data["ValuesLabel"]) {
+                    if (data["ValuesLabel"].hasOwnProperty(key))
+                        this.valuesLabel[key] = data["ValuesLabel"][key];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): NominalBinRange {
+        data = typeof data === 'object' ? data : {};
+        let result = new NominalBinRange();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.labelsValue) {
+            data["LabelsValue"] = {};
+            for (let key in this.labelsValue) {
+                if (this.labelsValue.hasOwnProperty(key))
+                    data["LabelsValue"][key] = this.labelsValue[key];
+            }
+        }
+        if (this.valuesLabel) {
+            data["ValuesLabel"] = {};
+            for (let key in this.valuesLabel) {
+                if (this.valuesLabel.hasOwnProperty(key))
+                    data["ValuesLabel"][key] = this.valuesLabel[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface INominalBinRange extends IBinRange {
+    labelsValue?: { [key: string]: number; } | undefined;
+    valuesLabel?: { [key: string]: string; } | undefined;
+}
+
+export class QuantitativeBinRange extends BinRange implements IQuantitativeBinRange {
+    isIntegerRange?: boolean | undefined;
+    step?: number | undefined;
+
+    constructor(data?: IQuantitativeBinRange) {
+        super(data);
+        this._discriminator = "QuantitativeBinRange";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.isIntegerRange = data["IsIntegerRange"];
+            this.step = data["Step"];
+        }
+    }
+
+    static fromJS(data: any): QuantitativeBinRange {
+        data = typeof data === 'object' ? data : {};
+        let result = new QuantitativeBinRange();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["IsIntegerRange"] = this.isIntegerRange;
+        data["Step"] = this.step;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IQuantitativeBinRange extends IBinRange {
+    isIntegerRange?: boolean | undefined;
+    step?: number | undefined;
+}
+
+export class AggregateBinRange extends BinRange implements IAggregateBinRange {
+
+    constructor(data?: IAggregateBinRange) {
+        super(data);
+        this._discriminator = "AggregateBinRange";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): AggregateBinRange {
+        data = typeof data === 'object' ? data : {};
+        let result = new AggregateBinRange();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAggregateBinRange extends IBinRange {
+}
+
+export class AlphabeticBinRange extends BinRange implements IAlphabeticBinRange {
+    prefix?: string | undefined;
+    labelsValue?: { [key: string]: number; } | undefined;
+    valuesLabel?: { [key: string]: string; } | undefined;
+
+    constructor(data?: IAlphabeticBinRange) {
+        super(data);
+        this._discriminator = "AlphabeticBinRange";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.prefix = data["Prefix"];
+            if (data["LabelsValue"]) {
+                this.labelsValue = {};
+                for (let key in data["LabelsValue"]) {
+                    if (data["LabelsValue"].hasOwnProperty(key))
+                        this.labelsValue[key] = data["LabelsValue"][key];
+                }
+            }
+            if (data["ValuesLabel"]) {
+                this.valuesLabel = {};
+                for (let key in data["ValuesLabel"]) {
+                    if (data["ValuesLabel"].hasOwnProperty(key))
+                        this.valuesLabel[key] = data["ValuesLabel"][key];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): AlphabeticBinRange {
+        data = typeof data === 'object' ? data : {};
+        let result = new AlphabeticBinRange();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Prefix"] = this.prefix;
+        if (this.labelsValue) {
+            data["LabelsValue"] = {};
+            for (let key in this.labelsValue) {
+                if (this.labelsValue.hasOwnProperty(key))
+                    data["LabelsValue"][key] = this.labelsValue[key];
+            }
+        }
+        if (this.valuesLabel) {
+            data["ValuesLabel"] = {};
+            for (let key in this.valuesLabel) {
+                if (this.valuesLabel.hasOwnProperty(key))
+                    data["ValuesLabel"][key] = this.valuesLabel[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAlphabeticBinRange extends IBinRange {
+    prefix?: string | undefined;
+    labelsValue?: { [key: string]: number; } | undefined;
+    valuesLabel?: { [key: string]: string; } | undefined;
+}
+
+export class DateTimeBinRange extends BinRange implements IDateTimeBinRange {
+    step?: DateTimeStep | undefined;
+
+    constructor(data?: IDateTimeBinRange) {
+        super(data);
+        this._discriminator = "DateTimeBinRange";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.step = data["Step"] ? DateTimeStep.fromJS(data["Step"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): DateTimeBinRange {
+        data = typeof data === 'object' ? data : {};
+        let result = new DateTimeBinRange();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Step"] = this.step ? this.step.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDateTimeBinRange extends IBinRange {
+    step?: DateTimeStep | undefined;
+}
+
+export class DateTimeStep implements IDateTimeStep {
+    dateTimeStepGranularity?: DateTimeStepGranularity | undefined;
+    dateTimeStepValue?: number | undefined;
+    dateTimeStepMaxValue?: number | undefined;
+
+    constructor(data?: IDateTimeStep) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.dateTimeStepGranularity = data["DateTimeStepGranularity"];
+            this.dateTimeStepValue = data["DateTimeStepValue"];
+            this.dateTimeStepMaxValue = data["DateTimeStepMaxValue"];
+        }
+    }
+
+    static fromJS(data: any): DateTimeStep {
+        data = typeof data === 'object' ? data : {};
+        let result = new DateTimeStep();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["DateTimeStepGranularity"] = this.dateTimeStepGranularity;
+        data["DateTimeStepValue"] = this.dateTimeStepValue;
+        data["DateTimeStepMaxValue"] = this.dateTimeStepMaxValue;
+        return data;
+    }
+}
+
+export interface IDateTimeStep {
+    dateTimeStepGranularity?: DateTimeStepGranularity | undefined;
+    dateTimeStepValue?: number | undefined;
+    dateTimeStepMaxValue?: number | undefined;
+}
+
+export enum DateTimeStepGranularity {
+    Second = 0,
+    Minute = 1,
+    Hour = 2,
+    Day = 3,
+    Month = 4,
+    Year = 5,
+}
+
+export class Bin implements IBin {
+    aggregateResults?: AggregateResult[] | undefined;
+    count?: number | undefined;
+    binIndex?: BinIndex | undefined;
+    spans?: Span[] | undefined;
+    xSize?: number | undefined;
+    ySize?: number | undefined;
+
+    constructor(data?: IBin) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["AggregateResults"] && data["AggregateResults"].constructor === Array) {
+                this.aggregateResults = [];
+                for (let item of data["AggregateResults"]) {
+                    let fromJs = AggregateResult.fromJS(item);
+                    if (fromJs)
+                        this.aggregateResults.push(fromJs);
+                }
+            }
+            this.count = data["Count"];
+            this.binIndex = data["BinIndex"] ? BinIndex.fromJS(data["BinIndex"]) : <any>undefined;
+            if (data["Spans"] && data["Spans"].constructor === Array) {
+                this.spans = [];
+                for (let item of data["Spans"])
+                    this.spans.push(Span.fromJS(item));
+            }
+            this.xSize = data["XSize"];
+            this.ySize = data["YSize"];
+        }
+    }
+
+    static fromJS(data: any): Bin {
+        data = typeof data === 'object' ? data : {};
+        let result = new Bin();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.aggregateResults && this.aggregateResults.constructor === Array) {
+            data["AggregateResults"] = [];
+            for (let item of this.aggregateResults)
+                data["AggregateResults"].push(item.toJSON());
+        }
+        data["Count"] = this.count;
+        data["BinIndex"] = this.binIndex ? this.binIndex.toJSON() : <any>undefined;
+        if (this.spans && this.spans.constructor === Array) {
+            data["Spans"] = [];
+            for (let item of this.spans)
+                data["Spans"].push(item.toJSON());
+        }
+        data["XSize"] = this.xSize;
+        data["YSize"] = this.ySize;
+        return data;
+    }
+}
+
+export interface IBin {
+    aggregateResults?: AggregateResult[] | undefined;
+    count?: number | undefined;
+    binIndex?: BinIndex | undefined;
+    spans?: Span[] | undefined;
+    xSize?: number | undefined;
+    ySize?: number | undefined;
+}
+
+export class BinIndex implements IBinIndex {
+    indices?: number[] | undefined;
+    flatIndex?: number | undefined;
+
+    constructor(data?: IBinIndex) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["Indices"] && data["Indices"].constructor === Array) {
+                this.indices = [];
+                for (let item of data["Indices"])
+                    this.indices.push(item);
+            }
+            this.flatIndex = data["FlatIndex"];
+        }
+    }
+
+    static fromJS(data: any): BinIndex {
+        data = typeof data === 'object' ? data : {};
+        let result = new BinIndex();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.indices && this.indices.constructor === Array) {
+            data["Indices"] = [];
+            for (let item of this.indices)
+                data["Indices"].push(item);
+        }
+        data["FlatIndex"] = this.flatIndex;
+        return data;
+    }
+}
+
+export interface IBinIndex {
+    indices?: number[] | undefined;
+    flatIndex?: number | undefined;
+}
+
+export class Span implements ISpan {
+    min?: number | undefined;
+    max?: number | undefined;
+    index?: number | undefined;
+
+    constructor(data?: ISpan) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.min = data["Min"];
+            this.max = data["Max"];
+            this.index = data["Index"];
+        }
+    }
+
+    static fromJS(data: any): Span {
+        data = typeof data === 'object' ? data : {};
+        let result = new Span();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Min"] = this.min;
+        data["Max"] = this.max;
+        data["Index"] = this.index;
+        return data;
+    }
+}
+
+export interface ISpan {
+    min?: number | undefined;
+    max?: number | undefined;
+    index?: number | undefined;
+}
+
+export class ModelWealthResult extends Result implements IModelWealthResult {
+    wealth?: number | undefined;
+    startWealth?: number | undefined;
+
+    constructor(data?: IModelWealthResult) {
+        super(data);
+        this._discriminator = "ModelWealthResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.wealth = data["Wealth"];
+            this.startWealth = data["StartWealth"];
+        }
+    }
+
+    static fromJS(data: any): ModelWealthResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new ModelWealthResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Wealth"] = this.wealth;
+        data["StartWealth"] = this.startWealth;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IModelWealthResult extends IResult {
+    wealth?: number | undefined;
+    startWealth?: number | undefined;
+}
+
+export abstract class HypothesisTestResult extends Result implements IHypothesisTestResult {
+    pValue?: number | undefined;
+    statistic?: number | undefined;
+    support?: number | undefined;
+    sampleSizes?: number[] | undefined;
+    errorMessage?: string | undefined;
+
+    constructor(data?: IHypothesisTestResult) {
+        super(data);
+        this._discriminator = "HypothesisTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.pValue = data["PValue"];
+            this.statistic = data["Statistic"];
+            this.support = data["Support"];
+            if (data["SampleSizes"] && data["SampleSizes"].constructor === Array) {
+                this.sampleSizes = [];
+                for (let item of data["SampleSizes"])
+                    this.sampleSizes.push(item);
+            }
+            this.errorMessage = data["ErrorMessage"];
+        }
+    }
+
+    static fromJS(data: any): HypothesisTestResult {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ChiSquaredTestResult") {
+            let result = new ChiSquaredTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CorrelationTestResult") {
+            let result = new CorrelationTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "KSTestResult") {
+            let result = new KSTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "RootMeanSquareTestResult") {
+            let result = new RootMeanSquareTestResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "TTestResult") {
+            let result = new TTestResult();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'HypothesisTestResult' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["PValue"] = this.pValue;
+        data["Statistic"] = this.statistic;
+        data["Support"] = this.support;
+        if (this.sampleSizes && this.sampleSizes.constructor === Array) {
+            data["SampleSizes"] = [];
+            for (let item of this.sampleSizes)
+                data["SampleSizes"].push(item);
+        }
+        data["ErrorMessage"] = this.errorMessage;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IHypothesisTestResult extends IResult {
+    pValue?: number | undefined;
+    statistic?: number | undefined;
+    support?: number | undefined;
+    sampleSizes?: number[] | undefined;
+    errorMessage?: string | undefined;
+}
+
+export abstract class ModelOperationResult extends Result implements IModelOperationResult {
+    modelId?: ModelId | undefined;
+
+    constructor(data?: IModelOperationResult) {
+        super(data);
+        this._discriminator = "ModelOperationResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.modelId = data["ModelId"] ? ModelId.fromJS(data["ModelId"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): ModelOperationResult {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "NewModelOperationResult") {
+            let result = new NewModelOperationResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "AddComparisonResult") {
+            let result = new AddComparisonResult();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "GetModelStateResult") {
+            let result = new GetModelStateResult();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'ModelOperationResult' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ModelId"] = this.modelId ? this.modelId.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IModelOperationResult extends IResult {
+    modelId?: ModelId | undefined;
+}
+
+export class RecommenderResult extends Result implements IRecommenderResult {
+    recommendedHistograms?: RecommendedHistogram[] | undefined;
+    totalCount?: number | undefined;
+
+    constructor(data?: IRecommenderResult) {
+        super(data);
+        this._discriminator = "RecommenderResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["RecommendedHistograms"] && data["RecommendedHistograms"].constructor === Array) {
+                this.recommendedHistograms = [];
+                for (let item of data["RecommendedHistograms"])
+                    this.recommendedHistograms.push(RecommendedHistogram.fromJS(item));
+            }
+            this.totalCount = data["TotalCount"];
+        }
+    }
+
+    static fromJS(data: any): RecommenderResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new RecommenderResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.recommendedHistograms && this.recommendedHistograms.constructor === Array) {
+            data["RecommendedHistograms"] = [];
+            for (let item of this.recommendedHistograms)
+                data["RecommendedHistograms"].push(item.toJSON());
+        }
+        data["TotalCount"] = this.totalCount;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRecommenderResult extends IResult {
+    recommendedHistograms?: RecommendedHistogram[] | undefined;
+    totalCount?: number | undefined;
+}
+
+export class RecommendedHistogram implements IRecommendedHistogram {
+    histogramResult?: HistogramResult | undefined;
+    selectedBinIndices?: BinIndex[] | undefined;
+    selections?: Selection[] | undefined;
+    pValue?: number | undefined;
+    significance?: boolean | undefined;
+    decision?: Decision | undefined;
+    effectSize?: number | undefined;
+    hypothesisTestResult?: HypothesisTestResult | undefined;
+    id?: string | undefined;
+    xAttribute?: Attribute | undefined;
+    yAttribute?: Attribute | undefined;
+
+    constructor(data?: IRecommendedHistogram) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.histogramResult = data["HistogramResult"] ? HistogramResult.fromJS(data["HistogramResult"]) : <any>undefined;
+            if (data["SelectedBinIndices"] && data["SelectedBinIndices"].constructor === Array) {
+                this.selectedBinIndices = [];
+                for (let item of data["SelectedBinIndices"])
+                    this.selectedBinIndices.push(BinIndex.fromJS(item));
+            }
+            if (data["Selections"] && data["Selections"].constructor === Array) {
+                this.selections = [];
+                for (let item of data["Selections"])
+                    this.selections.push(Selection.fromJS(item));
+            }
+            this.pValue = data["PValue"];
+            this.significance = data["Significance"];
+            this.decision = data["Decision"] ? Decision.fromJS(data["Decision"]) : <any>undefined;
+            this.effectSize = data["EffectSize"];
+            this.hypothesisTestResult = data["HypothesisTestResult"] ? HypothesisTestResult.fromJS(data["HypothesisTestResult"]) : <any>undefined;
+            this.id = data["Id"];
+            this.xAttribute = data["XAttribute"] ? Attribute.fromJS(data["XAttribute"]) : <any>undefined;
+            this.yAttribute = data["YAttribute"] ? Attribute.fromJS(data["YAttribute"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): RecommendedHistogram {
+        data = typeof data === 'object' ? data : {};
+        let result = new RecommendedHistogram();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["HistogramResult"] = this.histogramResult ? this.histogramResult.toJSON() : <any>undefined;
+        if (this.selectedBinIndices && this.selectedBinIndices.constructor === Array) {
+            data["SelectedBinIndices"] = [];
+            for (let item of this.selectedBinIndices)
+                data["SelectedBinIndices"].push(item.toJSON());
+        }
+        if (this.selections && this.selections.constructor === Array) {
+            data["Selections"] = [];
+            for (let item of this.selections)
+                data["Selections"].push(item.toJSON());
+        }
+        data["PValue"] = this.pValue;
+        data["Significance"] = this.significance;
+        data["Decision"] = this.decision ? this.decision.toJSON() : <any>undefined;
+        data["EffectSize"] = this.effectSize;
+        data["HypothesisTestResult"] = this.hypothesisTestResult ? this.hypothesisTestResult.toJSON() : <any>undefined;
+        data["Id"] = this.id;
+        data["XAttribute"] = this.xAttribute ? this.xAttribute.toJSON() : <any>undefined;
+        data["YAttribute"] = this.yAttribute ? this.yAttribute.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface IRecommendedHistogram {
+    histogramResult?: HistogramResult | undefined;
+    selectedBinIndices?: BinIndex[] | undefined;
+    selections?: Selection[] | undefined;
+    pValue?: number | undefined;
+    significance?: boolean | undefined;
+    decision?: Decision | undefined;
+    effectSize?: number | undefined;
+    hypothesisTestResult?: HypothesisTestResult | undefined;
+    id?: string | undefined;
+    xAttribute?: Attribute | undefined;
+    yAttribute?: Attribute | undefined;
+}
+
+export class Selection implements ISelection {
+    statements?: Statement[] | undefined;
+    filterHistogramOperationReference?: IOperationReference | undefined;
+
+    constructor(data?: ISelection) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["Statements"] && data["Statements"].constructor === Array) {
+                this.statements = [];
+                for (let item of data["Statements"])
+                    this.statements.push(Statement.fromJS(item));
+            }
+            this.filterHistogramOperationReference = data["FilterHistogramOperationReference"] ? IOperationReference.fromJS(data["FilterHistogramOperationReference"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): Selection {
+        data = typeof data === 'object' ? data : {};
+        let result = new Selection();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.statements && this.statements.constructor === Array) {
+            data["Statements"] = [];
+            for (let item of this.statements)
+                data["Statements"].push(item.toJSON());
+        }
+        data["FilterHistogramOperationReference"] = this.filterHistogramOperationReference ? this.filterHistogramOperationReference.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface ISelection {
+    statements?: Statement[] | undefined;
+    filterHistogramOperationReference?: IOperationReference | undefined;
+}
+
+export class Statement implements IStatement {
+    attribute?: Attribute | undefined;
+    predicate?: Predicate | undefined;
+    value?: any | undefined;
+
+    constructor(data?: IStatement) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.attribute = data["Attribute"] ? Attribute.fromJS(data["Attribute"]) : <any>undefined;
+            this.predicate = data["Predicate"];
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): Statement {
+        data = typeof data === 'object' ? data : {};
+        let result = new Statement();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Attribute"] = this.attribute ? this.attribute.toJSON() : <any>undefined;
+        data["Predicate"] = this.predicate;
+        data["Value"] = this.value;
+        return data;
+    }
+}
+
+export interface IStatement {
+    attribute?: Attribute | undefined;
+    predicate?: Predicate | undefined;
+    value?: any | undefined;
+}
+
+export enum Predicate {
+    EQUALS = 0,
+    LIKE = 1,
+    GREATER_THAN = 2,
+    LESS_THAN = 3,
+    GREATER_THAN_EQUAL = 4,
+    LESS_THAN_EQUAL = 5,
+    STARTS_WITH = 6,
+    ENDS_WITH = 7,
+    CONTAINS = 8,
+}
+
+export abstract class IOperationReference implements IIOperationReference {
+    id?: string | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IIOperationReference) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "IOperationReference";
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+        }
+    }
+
+    static fromJS(data: any): IOperationReference {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "OperationReference") {
+            let result = new OperationReference();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'IOperationReference' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["Id"] = this.id;
+        return data;
+    }
+}
+
+export interface IIOperationReference {
+    id?: string | undefined;
+}
+
+export class OperationReference extends IOperationReference implements IOperationReference {
+    id?: string | undefined;
+
+    constructor(data?: IOperationReference) {
+        super(data);
+        this._discriminator = "OperationReference";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.id = data["Id"];
+        }
+    }
+
+    static fromJS(data: any): OperationReference {
+        data = typeof data === 'object' ? data : {};
+        let result = new OperationReference();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IOperationReference extends IIOperationReference {
+    id?: string | undefined;
+}
+
+export class Decision extends Result implements IDecision {
+    comparisonId?: ComparisonId | undefined;
+    riskControlType?: RiskControlType | undefined;
+    significance?: boolean | undefined;
+    pValue?: number | undefined;
+    lhs?: number | undefined;
+    significanceLevel?: number | undefined;
+    sampleSizeEstimate?: number | undefined;
+
+    constructor(data?: IDecision) {
+        super(data);
+        this._discriminator = "Decision";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.comparisonId = data["ComparisonId"] ? ComparisonId.fromJS(data["ComparisonId"]) : <any>undefined;
+            this.riskControlType = data["RiskControlType"];
+            this.significance = data["Significance"];
+            this.pValue = data["PValue"];
+            this.lhs = data["Lhs"];
+            this.significanceLevel = data["SignificanceLevel"];
+            this.sampleSizeEstimate = data["SampleSizeEstimate"];
+        }
+    }
+
+    static fromJS(data: any): Decision {
+        data = typeof data === 'object' ? data : {};
+        let result = new Decision();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ComparisonId"] = this.comparisonId ? this.comparisonId.toJSON() : <any>undefined;
+        data["RiskControlType"] = this.riskControlType;
+        data["Significance"] = this.significance;
+        data["PValue"] = this.pValue;
+        data["Lhs"] = this.lhs;
+        data["SignificanceLevel"] = this.significanceLevel;
+        data["SampleSizeEstimate"] = this.sampleSizeEstimate;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDecision extends IResult {
+    comparisonId?: ComparisonId | undefined;
+    riskControlType?: RiskControlType | undefined;
+    significance?: boolean | undefined;
+    pValue?: number | undefined;
+    lhs?: number | undefined;
+    significanceLevel?: number | undefined;
+    sampleSizeEstimate?: number | undefined;
+}
+
+export class ComparisonId implements IComparisonId {
+    value?: string | undefined;
+
+    constructor(data?: IComparisonId) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): ComparisonId {
+        data = typeof data === 'object' ? data : {};
+        let result = new ComparisonId();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        return data;
+    }
+}
+
+export interface IComparisonId {
+    value?: string | undefined;
+}
+
+export class OptimizerResult extends Result implements IOptimizerResult {
+    topKSolutions?: Solution[] | undefined;
+
+    constructor(data?: IOptimizerResult) {
+        super(data);
+        this._discriminator = "OptimizerResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["TopKSolutions"] && data["TopKSolutions"].constructor === Array) {
+                this.topKSolutions = [];
+                for (let item of data["TopKSolutions"])
+                    this.topKSolutions.push(Solution.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): OptimizerResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new OptimizerResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.topKSolutions && this.topKSolutions.constructor === Array) {
+            data["TopKSolutions"] = [];
+            for (let item of this.topKSolutions)
+                data["TopKSolutions"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IOptimizerResult extends IResult {
+    topKSolutions?: Solution[] | undefined;
+}
+
+export class Solution implements ISolution {
+    solutionId?: string | undefined;
+    stepDescriptions?: StepDescription[] | undefined;
+    pipelineDescription?: PipelineDescription | undefined;
+    score?: Score | undefined;
+    naiveScore?: Score | undefined;
+
+    constructor(data?: ISolution) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.solutionId = data["SolutionId"];
+            if (data["StepDescriptions"] && data["StepDescriptions"].constructor === Array) {
+                this.stepDescriptions = [];
+                for (let item of data["StepDescriptions"])
+                    this.stepDescriptions.push(StepDescription.fromJS(item));
+            }
+            this.pipelineDescription = data["PipelineDescription"] ? PipelineDescription.fromJS(data["PipelineDescription"]) : <any>undefined;
+            this.score = data["Score"] ? Score.fromJS(data["Score"]) : <any>undefined;
+            this.naiveScore = data["NaiveScore"] ? Score.fromJS(data["NaiveScore"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): Solution {
+        data = typeof data === 'object' ? data : {};
+        let result = new Solution();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SolutionId"] = this.solutionId;
+        if (this.stepDescriptions && this.stepDescriptions.constructor === Array) {
+            data["StepDescriptions"] = [];
+            for (let item of this.stepDescriptions)
+                data["StepDescriptions"].push(item.toJSON());
+        }
+        data["PipelineDescription"] = this.pipelineDescription ? this.pipelineDescription.toJSON() : <any>undefined;
+        data["Score"] = this.score ? this.score.toJSON() : <any>undefined;
+        data["NaiveScore"] = this.naiveScore ? this.naiveScore.toJSON() : <any>undefined;
+        return data;
+    }
+}
+
+export interface ISolution {
+    solutionId?: string | undefined;
+    stepDescriptions?: StepDescription[] | undefined;
+    pipelineDescription?: PipelineDescription | undefined;
+    score?: Score | undefined;
+    naiveScore?: Score | undefined;
+}
+
+export class StepDescription implements IStepDescription {
+
+    protected _discriminator: string;
+
+    constructor(data?: IStepDescription) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "StepDescription";
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): StepDescription {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "SubpipelineStepDescription") {
+            let result = new SubpipelineStepDescription();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PrimitiveStepDescription") {
+            let result = new PrimitiveStepDescription();
+            result.init(data);
+            return result;
+        }
+        let result = new StepDescription();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        return data;
+    }
+}
+
+export interface IStepDescription {
+}
+
+export class SubpipelineStepDescription extends StepDescription implements ISubpipelineStepDescription {
+    steps?: StepDescription[] | undefined;
+
+    constructor(data?: ISubpipelineStepDescription) {
+        super(data);
+        this._discriminator = "SubpipelineStepDescription";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Steps"] && data["Steps"].constructor === Array) {
+                this.steps = [];
+                for (let item of data["Steps"])
+                    this.steps.push(StepDescription.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): SubpipelineStepDescription {
+        data = typeof data === 'object' ? data : {};
+        let result = new SubpipelineStepDescription();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.steps && this.steps.constructor === Array) {
+            data["Steps"] = [];
+            for (let item of this.steps)
+                data["Steps"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISubpipelineStepDescription extends IStepDescription {
+    steps?: StepDescription[] | undefined;
+}
+
+export class PipelineDescription implements IPipelineDescription {
+    id?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    inputs?: PipelineDescriptionInput[] | undefined;
+    outputs?: PipelineDescriptionOutput[] | undefined;
+    steps?: PipelineDescriptionStep[] | undefined;
+
+    constructor(data?: IPipelineDescription) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+            this.name = data["Name"];
+            this.description = data["Description"];
+            if (data["Inputs"] && data["Inputs"].constructor === Array) {
+                this.inputs = [];
+                for (let item of data["Inputs"])
+                    this.inputs.push(PipelineDescriptionInput.fromJS(item));
+            }
+            if (data["Outputs"] && data["Outputs"].constructor === Array) {
+                this.outputs = [];
+                for (let item of data["Outputs"])
+                    this.outputs.push(PipelineDescriptionOutput.fromJS(item));
+            }
+            if (data["Steps"] && data["Steps"].constructor === Array) {
+                this.steps = [];
+                for (let item of data["Steps"])
+                    this.steps.push(PipelineDescriptionStep.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): PipelineDescription {
+        data = typeof data === 'object' ? data : {};
+        let result = new PipelineDescription();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        data["Name"] = this.name;
+        data["Description"] = this.description;
+        if (this.inputs && this.inputs.constructor === Array) {
+            data["Inputs"] = [];
+            for (let item of this.inputs)
+                data["Inputs"].push(item.toJSON());
+        }
+        if (this.outputs && this.outputs.constructor === Array) {
+            data["Outputs"] = [];
+            for (let item of this.outputs)
+                data["Outputs"].push(item.toJSON());
+        }
+        if (this.steps && this.steps.constructor === Array) {
+            data["Steps"] = [];
+            for (let item of this.steps)
+                data["Steps"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IPipelineDescription {
+    id?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    inputs?: PipelineDescriptionInput[] | undefined;
+    outputs?: PipelineDescriptionOutput[] | undefined;
+    steps?: PipelineDescriptionStep[] | undefined;
+}
+
+export class PipelineDescriptionInput implements IPipelineDescriptionInput {
+    name?: string | undefined;
+
+    constructor(data?: IPipelineDescriptionInput) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.name = data["Name"];
+        }
+    }
+
+    static fromJS(data: any): PipelineDescriptionInput {
+        data = typeof data === 'object' ? data : {};
+        let result = new PipelineDescriptionInput();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Name"] = this.name;
+        return data;
+    }
+}
+
+export interface IPipelineDescriptionInput {
+    name?: string | undefined;
+}
+
+export class PipelineDescriptionOutput implements IPipelineDescriptionOutput {
+    name?: string | undefined;
+    data?: string | undefined;
+
+    constructor(data?: IPipelineDescriptionOutput) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.name = data["Name"];
+            this.data = data["Data"];
+        }
+    }
+
+    static fromJS(data: any): PipelineDescriptionOutput {
+        data = typeof data === 'object' ? data : {};
+        let result = new PipelineDescriptionOutput();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Name"] = this.name;
+        data["Data"] = this.data;
+        return data;
+    }
+}
+
+export interface IPipelineDescriptionOutput {
+    name?: string | undefined;
+    data?: string | undefined;
+}
+
+export class PipelineDescriptionStep implements IPipelineDescriptionStep {
+    outputs?: StepOutput[] | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IPipelineDescriptionStep) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "PipelineDescriptionStep";
+    }
+
+    init(data?: any) {
+        if (data) {
+            if (data["Outputs"] && data["Outputs"].constructor === Array) {
+                this.outputs = [];
+                for (let item of data["Outputs"])
+                    this.outputs.push(StepOutput.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): PipelineDescriptionStep {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "PlaceholderPipelineDescriptionStep") {
+            let result = new PlaceholderPipelineDescriptionStep();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "SubpipelinePipelineDescriptionStep") {
+            let result = new SubpipelinePipelineDescriptionStep();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PrimitivePipelineDescriptionStep") {
+            let result = new PrimitivePipelineDescriptionStep();
+            result.init(data);
+            return result;
+        }
+        let result = new PipelineDescriptionStep();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        if (this.outputs && this.outputs.constructor === Array) {
+            data["Outputs"] = [];
+            for (let item of this.outputs)
+                data["Outputs"].push(item.toJSON());
+        }
+        return data;
+    }
+}
+
+export interface IPipelineDescriptionStep {
+    outputs?: StepOutput[] | undefined;
+}
+
+export class StepOutput implements IStepOutput {
+    id?: string | undefined;
+
+    constructor(data?: IStepOutput) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+        }
+    }
+
+    static fromJS(data: any): StepOutput {
+        data = typeof data === 'object' ? data : {};
+        let result = new StepOutput();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        return data;
+    }
+}
+
+export interface IStepOutput {
+    id?: string | undefined;
+}
+
+export class PlaceholderPipelineDescriptionStep extends PipelineDescriptionStep implements IPlaceholderPipelineDescriptionStep {
+    inputs?: StepInput[] | undefined;
+
+    constructor(data?: IPlaceholderPipelineDescriptionStep) {
+        super(data);
+        this._discriminator = "PlaceholderPipelineDescriptionStep";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Inputs"] && data["Inputs"].constructor === Array) {
+                this.inputs = [];
+                for (let item of data["Inputs"])
+                    this.inputs.push(StepInput.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): PlaceholderPipelineDescriptionStep {
+        data = typeof data === 'object' ? data : {};
+        let result = new PlaceholderPipelineDescriptionStep();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.inputs && this.inputs.constructor === Array) {
+            data["Inputs"] = [];
+            for (let item of this.inputs)
+                data["Inputs"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPlaceholderPipelineDescriptionStep extends IPipelineDescriptionStep {
+    inputs?: StepInput[] | undefined;
+}
+
+export class StepInput implements IStepInput {
+    data?: string | undefined;
+
+    constructor(data?: IStepInput) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.data = data["Data"];
+        }
+    }
+
+    static fromJS(data: any): StepInput {
+        data = typeof data === 'object' ? data : {};
+        let result = new StepInput();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Data"] = this.data;
+        return data;
+    }
+}
+
+export interface IStepInput {
+    data?: string | undefined;
+}
+
+export class SubpipelinePipelineDescriptionStep extends PipelineDescriptionStep implements ISubpipelinePipelineDescriptionStep {
+    pipelineDescription?: PipelineDescription | undefined;
+    inputs?: StepInput[] | undefined;
+
+    constructor(data?: ISubpipelinePipelineDescriptionStep) {
+        super(data);
+        this._discriminator = "SubpipelinePipelineDescriptionStep";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.pipelineDescription = data["PipelineDescription"] ? PipelineDescription.fromJS(data["PipelineDescription"]) : <any>undefined;
+            if (data["Inputs"] && data["Inputs"].constructor === Array) {
+                this.inputs = [];
+                for (let item of data["Inputs"])
+                    this.inputs.push(StepInput.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): SubpipelinePipelineDescriptionStep {
+        data = typeof data === 'object' ? data : {};
+        let result = new SubpipelinePipelineDescriptionStep();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["PipelineDescription"] = this.pipelineDescription ? this.pipelineDescription.toJSON() : <any>undefined;
+        if (this.inputs && this.inputs.constructor === Array) {
+            data["Inputs"] = [];
+            for (let item of this.inputs)
+                data["Inputs"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISubpipelinePipelineDescriptionStep extends IPipelineDescriptionStep {
+    pipelineDescription?: PipelineDescription | undefined;
+    inputs?: StepInput[] | undefined;
+}
+
+export class PrimitivePipelineDescriptionStep extends PipelineDescriptionStep implements IPrimitivePipelineDescriptionStep {
+    primitive?: Primitive | undefined;
+    arguments?: { [key: string]: PrimitiveStepArgument; } | undefined;
+    hyperparams?: { [key: string]: PrimitiveStepHyperparameter; } | undefined;
+
+    constructor(data?: IPrimitivePipelineDescriptionStep) {
+        super(data);
+        this._discriminator = "PrimitivePipelineDescriptionStep";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.primitive = data["Primitive"] ? Primitive.fromJS(data["Primitive"]) : <any>undefined;
+            if (data["Arguments"]) {
+                this.arguments = {};
+                for (let key in data["Arguments"]) {
+                    if (data["Arguments"].hasOwnProperty(key))
+                        this.arguments[key] = data["Arguments"][key] ? PrimitiveStepArgument.fromJS(data["Arguments"][key]) : new PrimitiveStepArgument();
+                }
+            }
+            if (data["Hyperparams"]) {
+                this.hyperparams = {};
+                for (let key in data["Hyperparams"]) {
+                    if (data["Hyperparams"].hasOwnProperty(key))
+                        this.hyperparams[key] = data["Hyperparams"][key] ? PrimitiveStepHyperparameter.fromJS(data["Hyperparams"][key]) : new PrimitiveStepHyperparameter();
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): PrimitivePipelineDescriptionStep {
+        data = typeof data === 'object' ? data : {};
+        let result = new PrimitivePipelineDescriptionStep();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Primitive"] = this.primitive ? this.primitive.toJSON() : <any>undefined;
+        if (this.arguments) {
+            data["Arguments"] = {};
+            for (let key in this.arguments) {
+                if (this.arguments.hasOwnProperty(key))
+                    data["Arguments"][key] = this.arguments[key];
+            }
+        }
+        if (this.hyperparams) {
+            data["Hyperparams"] = {};
+            for (let key in this.hyperparams) {
+                if (this.hyperparams.hasOwnProperty(key))
+                    data["Hyperparams"][key] = this.hyperparams[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPrimitivePipelineDescriptionStep extends IPipelineDescriptionStep {
+    primitive?: Primitive | undefined;
+    arguments?: { [key: string]: PrimitiveStepArgument; } | undefined;
+    hyperparams?: { [key: string]: PrimitiveStepHyperparameter; } | undefined;
+}
+
+export class Primitive implements IPrimitive {
+    id?: string | undefined;
+    version?: string | undefined;
+    pythonPath?: string | undefined;
+    name?: string | undefined;
+    digest?: string | undefined;
+
+    constructor(data?: IPrimitive) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.id = data["Id"];
+            this.version = data["Version"];
+            this.pythonPath = data["PythonPath"];
+            this.name = data["Name"];
+            this.digest = data["Digest"];
+        }
+    }
+
+    static fromJS(data: any): Primitive {
+        data = typeof data === 'object' ? data : {};
+        let result = new Primitive();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Id"] = this.id;
+        data["Version"] = this.version;
+        data["PythonPath"] = this.pythonPath;
+        data["Name"] = this.name;
+        data["Digest"] = this.digest;
+        return data;
+    }
+}
+
+export interface IPrimitive {
+    id?: string | undefined;
+    version?: string | undefined;
+    pythonPath?: string | undefined;
+    name?: string | undefined;
+    digest?: string | undefined;
+}
+
+export class PrimitiveStepHyperparameter implements IPrimitiveStepHyperparameter {
+
+    protected _discriminator: string;
+
+    constructor(data?: IPrimitiveStepHyperparameter) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "PrimitiveStepHyperparameter";
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): PrimitiveStepHyperparameter {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "PrimitiveStepArgument") {
+            let result = new PrimitiveStepArgument();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DataArguments") {
+            let result = new DataArguments();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PrimitiveArgument") {
+            let result = new PrimitiveArgument();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PrimitiveArguments") {
+            let result = new PrimitiveArguments();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ValueArgument") {
+            let result = new ValueArgument();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ContainerArgument") {
+            let result = new ContainerArgument();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DataArgument") {
+            let result = new DataArgument();
+            result.init(data);
+            return result;
+        }
+        let result = new PrimitiveStepHyperparameter();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        return data;
+    }
+}
+
+export interface IPrimitiveStepHyperparameter {
+}
+
+export class PrimitiveStepArgument extends PrimitiveStepHyperparameter implements IPrimitiveStepArgument {
+
+    protected _discriminator: string;
+
+    constructor(data?: IPrimitiveStepArgument) {
+        super(data);
+        this._discriminator = "PrimitiveStepArgument";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): PrimitiveStepArgument {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ContainerArgument") {
+            let result = new ContainerArgument();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DataArgument") {
+            let result = new DataArgument();
+            result.init(data);
+            return result;
+        }
+        let result = new PrimitiveStepArgument();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPrimitiveStepArgument extends IPrimitiveStepHyperparameter {
+}
+
+export class DataArguments extends PrimitiveStepHyperparameter implements IDataArguments {
+    data?: string[] | undefined;
+
+    constructor(data?: IDataArguments) {
+        super(data);
+        this._discriminator = "DataArguments";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Data"] && data["Data"].constructor === Array) {
+                this.data = [];
+                for (let item of data["Data"])
+                    this.data.push(item);
+            }
+        }
+    }
+
+    static fromJS(data: any): DataArguments {
+        data = typeof data === 'object' ? data : {};
+        let result = new DataArguments();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.data && this.data.constructor === Array) {
+            data["Data"] = [];
+            for (let item of this.data)
+                data["Data"].push(item);
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDataArguments extends IPrimitiveStepHyperparameter {
+    data?: string[] | undefined;
+}
+
+export class PrimitiveArgument extends PrimitiveStepHyperparameter implements IPrimitiveArgument {
+    data?: number | undefined;
+
+    constructor(data?: IPrimitiveArgument) {
+        super(data);
+        this._discriminator = "PrimitiveArgument";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.data = data["Data"];
+        }
+    }
+
+    static fromJS(data: any): PrimitiveArgument {
+        data = typeof data === 'object' ? data : {};
+        let result = new PrimitiveArgument();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Data"] = this.data;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPrimitiveArgument extends IPrimitiveStepHyperparameter {
+    data?: number | undefined;
+}
+
+export class PrimitiveArguments extends PrimitiveStepHyperparameter implements IPrimitiveArguments {
+    data?: number[] | undefined;
+
+    constructor(data?: IPrimitiveArguments) {
+        super(data);
+        this._discriminator = "PrimitiveArguments";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Data"] && data["Data"].constructor === Array) {
+                this.data = [];
+                for (let item of data["Data"])
+                    this.data.push(item);
+            }
+        }
+    }
+
+    static fromJS(data: any): PrimitiveArguments {
+        data = typeof data === 'object' ? data : {};
+        let result = new PrimitiveArguments();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.data && this.data.constructor === Array) {
+            data["Data"] = [];
+            for (let item of this.data)
+                data["Data"].push(item);
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPrimitiveArguments extends IPrimitiveStepHyperparameter {
+    data?: number[] | undefined;
+}
+
+export class ValueArgument extends PrimitiveStepHyperparameter implements IValueArgument {
+    data?: Value | undefined;
+
+    constructor(data?: IValueArgument) {
+        super(data);
+        this._discriminator = "ValueArgument";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.data = data["Data"] ? Value.fromJS(data["Data"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): ValueArgument {
+        data = typeof data === 'object' ? data : {};
+        let result = new ValueArgument();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Data"] = this.data ? this.data.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IValueArgument extends IPrimitiveStepHyperparameter {
+    data?: Value | undefined;
+}
+
+export abstract class Value implements IValue {
+
+    protected _discriminator: string;
+
+    constructor(data?: IValue) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+        this._discriminator = "Value";
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): Value {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "ErrorValue") {
+            let result = new ErrorValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DoubleValue") {
+            let result = new DoubleValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "LongValue") {
+            let result = new LongValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "BoolValue") {
+            let result = new BoolValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "StringValue") {
+            let result = new StringValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "DatasetUriValue") {
+            let result = new DatasetUriValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "CsvUriValue") {
+            let result = new CsvUriValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PickleUriValue") {
+            let result = new PickleUriValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PickleBlobValue") {
+            let result = new PickleBlobValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "PlasmaIdValue") {
+            let result = new PlasmaIdValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "BytesValue") {
+            let result = new BytesValue();
+            result.init(data);
+            return result;
+        }
+        if (data["discriminator"] === "ListValue") {
+            let result = new ListValue();
+            result.init(data);
+            return result;
+        }
+        throw new Error("The abstract class 'Value' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        return data;
+    }
+}
+
+export interface IValue {
+}
+
+export class ErrorValue extends Value implements IErrorValue {
+    message?: string | undefined;
+
+    constructor(data?: IErrorValue) {
+        super(data);
+        this._discriminator = "ErrorValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.message = data["Message"];
+        }
+    }
+
+    static fromJS(data: any): ErrorValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new ErrorValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Message"] = this.message;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IErrorValue extends IValue {
+    message?: string | undefined;
+}
+
+export class DoubleValue extends Value implements IDoubleValue {
+    value?: number | undefined;
+
+    constructor(data?: IDoubleValue) {
+        super(data);
+        this._discriminator = "DoubleValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): DoubleValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new DoubleValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDoubleValue extends IValue {
+    value?: number | undefined;
+}
+
+export class LongValue extends Value implements ILongValue {
+    value?: number | undefined;
+
+    constructor(data?: ILongValue) {
+        super(data);
+        this._discriminator = "LongValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): LongValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new LongValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ILongValue extends IValue {
+    value?: number | undefined;
+}
+
+export class BoolValue extends Value implements IBoolValue {
+    value?: boolean | undefined;
+
+    constructor(data?: IBoolValue) {
+        super(data);
+        this._discriminator = "BoolValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): BoolValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new BoolValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IBoolValue extends IValue {
+    value?: boolean | undefined;
+}
+
+export class StringValue extends Value implements IStringValue {
+    value?: string | undefined;
+
+    constructor(data?: IStringValue) {
+        super(data);
+        this._discriminator = "StringValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): StringValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new StringValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IStringValue extends IValue {
+    value?: string | undefined;
+}
+
+export class DatasetUriValue extends Value implements IDatasetUriValue {
+    value?: string | undefined;
+
+    constructor(data?: IDatasetUriValue) {
+        super(data);
+        this._discriminator = "DatasetUriValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): DatasetUriValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new DatasetUriValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDatasetUriValue extends IValue {
+    value?: string | undefined;
+}
+
+export class CsvUriValue extends Value implements ICsvUriValue {
+    value?: string | undefined;
+
+    constructor(data?: ICsvUriValue) {
+        super(data);
+        this._discriminator = "CsvUriValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): CsvUriValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new CsvUriValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICsvUriValue extends IValue {
+    value?: string | undefined;
+}
+
+export class PickleUriValue extends Value implements IPickleUriValue {
+    value?: string | undefined;
+
+    constructor(data?: IPickleUriValue) {
+        super(data);
+        this._discriminator = "PickleUriValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): PickleUriValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new PickleUriValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPickleUriValue extends IValue {
+    value?: string | undefined;
+}
+
+export class PickleBlobValue extends Value implements IPickleBlobValue {
+    value?: string | undefined;
+
+    constructor(data?: IPickleBlobValue) {
+        super(data);
+        this._discriminator = "PickleBlobValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): PickleBlobValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new PickleBlobValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPickleBlobValue extends IValue {
+    value?: string | undefined;
+}
+
+export class PlasmaIdValue extends Value implements IPlasmaIdValue {
+    value?: string | undefined;
+
+    constructor(data?: IPlasmaIdValue) {
+        super(data);
+        this._discriminator = "PlasmaIdValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): PlasmaIdValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new PlasmaIdValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPlasmaIdValue extends IValue {
+    value?: string | undefined;
+}
+
+export class BytesValue extends Value implements IBytesValue {
+    value?: string | undefined;
+
+    constructor(data?: IBytesValue) {
+        super(data);
+        this._discriminator = "BytesValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): BytesValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new BytesValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IBytesValue extends IValue {
+    value?: string | undefined;
+}
+
+export class ContainerArgument extends PrimitiveStepArgument implements IContainerArgument {
+    data?: string | undefined;
+
+    constructor(data?: IContainerArgument) {
+        super(data);
+        this._discriminator = "ContainerArgument";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.data = data["Data"];
+        }
+    }
+
+    static fromJS(data: any): ContainerArgument {
+        data = typeof data === 'object' ? data : {};
+        let result = new ContainerArgument();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Data"] = this.data;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IContainerArgument extends IPrimitiveStepArgument {
+    data?: string | undefined;
+}
+
+export class Score implements IScore {
+    metricType?: MetricType | undefined;
+    value?: number | undefined;
+
+    constructor(data?: IScore) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.metricType = data["MetricType"];
+            this.value = data["Value"];
+        }
+    }
+
+    static fromJS(data: any): Score {
+        data = typeof data === 'object' ? data : {};
+        let result = new Score();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["MetricType"] = this.metricType;
+        data["Value"] = this.value;
+        return data;
+    }
+}
+
+export interface IScore {
+    metricType?: MetricType | undefined;
+    value?: number | undefined;
+}
+
+export class ExampleResult extends Result implements IExampleResult {
+    resultValues?: { [key: string]: string; } | undefined;
+    message?: string | undefined;
+
+    constructor(data?: IExampleResult) {
+        super(data);
+        this._discriminator = "ExampleResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["ResultValues"]) {
+                this.resultValues = {};
+                for (let key in data["ResultValues"]) {
+                    if (data["ResultValues"].hasOwnProperty(key))
+                        this.resultValues[key] = data["ResultValues"][key];
+                }
+            }
+            this.message = data["Message"];
+        }
+    }
+
+    static fromJS(data: any): ExampleResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new ExampleResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.resultValues) {
+            data["ResultValues"] = {};
+            for (let key in this.resultValues) {
+                if (this.resultValues.hasOwnProperty(key))
+                    data["ResultValues"][key] = this.resultValues[key];
+            }
+        }
+        data["Message"] = this.message;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IExampleResult extends IResult {
+    resultValues?: { [key: string]: string; } | undefined;
+    message?: string | undefined;
+}
+
+export class NewModelOperationResult extends ModelOperationResult implements INewModelOperationResult {
+
+    constructor(data?: INewModelOperationResult) {
+        super(data);
+        this._discriminator = "NewModelOperationResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): NewModelOperationResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new NewModelOperationResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface INewModelOperationResult extends IModelOperationResult {
+}
+
+export class AddComparisonResult extends ModelOperationResult implements IAddComparisonResult {
+    comparisonId?: ComparisonId | undefined;
+
+    constructor(data?: IAddComparisonResult) {
+        super(data);
+        this._discriminator = "AddComparisonResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.comparisonId = data["ComparisonId"] ? ComparisonId.fromJS(data["ComparisonId"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): AddComparisonResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new AddComparisonResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ComparisonId"] = this.comparisonId ? this.comparisonId.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAddComparisonResult extends IModelOperationResult {
+    comparisonId?: ComparisonId | undefined;
+}
+
+export class GetModelStateResult extends ModelOperationResult implements IGetModelStateResult {
+    decisions?: Decision[] | undefined;
+    startingWealth?: number | undefined;
+    currentWealth?: number | undefined;
+
+    constructor(data?: IGetModelStateResult) {
+        super(data);
+        this._discriminator = "GetModelStateResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Decisions"] && data["Decisions"].constructor === Array) {
+                this.decisions = [];
+                for (let item of data["Decisions"])
+                    this.decisions.push(Decision.fromJS(item));
+            }
+            this.startingWealth = data["StartingWealth"];
+            this.currentWealth = data["CurrentWealth"];
+        }
+    }
+
+    static fromJS(data: any): GetModelStateResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new GetModelStateResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.decisions && this.decisions.constructor === Array) {
+            data["Decisions"] = [];
+            for (let item of this.decisions)
+                data["Decisions"].push(item.toJSON());
+        }
+        data["StartingWealth"] = this.startingWealth;
+        data["CurrentWealth"] = this.currentWealth;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IGetModelStateResult extends IModelOperationResult {
+    decisions?: Decision[] | undefined;
+    startingWealth?: number | undefined;
+    currentWealth?: number | undefined;
+}
+
+export class AggregateKey implements IAggregateKey {
+    aggregateParameterIndex?: number | undefined;
+    brushIndex?: number | undefined;
+
+    constructor(data?: IAggregateKey) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.aggregateParameterIndex = data["AggregateParameterIndex"];
+            this.brushIndex = data["BrushIndex"];
+        }
+    }
+
+    static fromJS(data: any): AggregateKey {
+        data = typeof data === 'object' ? data : {};
+        let result = new AggregateKey();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AggregateParameterIndex"] = this.aggregateParameterIndex;
+        data["BrushIndex"] = this.brushIndex;
+        return data;
+    }
+}
+
+export interface IAggregateKey {
+    aggregateParameterIndex?: number | undefined;
+    brushIndex?: number | undefined;
+}
+
+export abstract class IResult implements IIResult {
+
+    constructor(data?: IIResult) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): IResult {
+        data = typeof data === 'object' ? data : {};
+        throw new Error("The abstract class 'IResult' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        return data;
+    }
+}
+
+export interface IIResult {
+}
+
+export class DataArgument extends PrimitiveStepArgument implements IDataArgument {
+    data?: string | undefined;
+
+    constructor(data?: IDataArgument) {
+        super(data);
+        this._discriminator = "DataArgument";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.data = data["Data"];
+        }
+    }
+
+    static fromJS(data: any): DataArgument {
+        data = typeof data === 'object' ? data : {};
+        let result = new DataArgument();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Data"] = this.data;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IDataArgument extends IPrimitiveStepArgument {
+    data?: string | undefined;
+}
+
+export class ListValue extends Value implements IListValue {
+    items?: Value[] | undefined;
+
+    constructor(data?: IListValue) {
+        super(data);
+        this._discriminator = "ListValue";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Items"] && data["Items"].constructor === Array) {
+                this.items = [];
+                for (let item of data["Items"])
+                    this.items.push(Value.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): ListValue {
+        data = typeof data === 'object' ? data : {};
+        let result = new ListValue();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.items && this.items.constructor === Array) {
+            data["Items"] = [];
+            for (let item of this.items)
+                data["Items"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IListValue extends IValue {
+    items?: Value[] | undefined;
+}
+
+export class Metrics implements IMetrics {
+    averageAccuracy?: number | undefined;
+    averageRSquared?: number | undefined;
+    f1Macro?: number | undefined;
+
+    constructor(data?: IMetrics) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.averageAccuracy = data["AverageAccuracy"];
+            this.averageRSquared = data["AverageRSquared"];
+            this.f1Macro = data["F1Macro"];
+        }
+    }
+
+    static fromJS(data: any): Metrics {
+        data = typeof data === 'object' ? data : {};
+        let result = new Metrics();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AverageAccuracy"] = this.averageAccuracy;
+        data["AverageRSquared"] = this.averageRSquared;
+        data["F1Macro"] = this.f1Macro;
+        return data;
+    }
+}
+
+export interface IMetrics {
+    averageAccuracy?: number | undefined;
+    averageRSquared?: number | undefined;
+    f1Macro?: number | undefined;
+}
+
+export class FeatureImportanceOperationParameters extends DistOperationParameters implements IFeatureImportanceOperationParameters {
+    solutionId?: string | undefined;
+
+    constructor(data?: IFeatureImportanceOperationParameters) {
+        super(data);
+        this._discriminator = "FeatureImportanceOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.solutionId = data["SolutionId"];
+        }
+    }
+
+    static fromJS(data: any): FeatureImportanceOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new FeatureImportanceOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SolutionId"] = this.solutionId;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IFeatureImportanceOperationParameters extends IDistOperationParameters {
+    solutionId?: string | undefined;
+}
+
+export class FeatureImportanceResult extends Result implements IFeatureImportanceResult {
+    featureImportances?: { [key: string]: TupleOfDoubleAndDouble; } | undefined;
+
+    constructor(data?: IFeatureImportanceResult) {
+        super(data);
+        this._discriminator = "FeatureImportanceResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["FeatureImportances"]) {
+                this.featureImportances = {};
+                for (let key in data["FeatureImportances"]) {
+                    if (data["FeatureImportances"].hasOwnProperty(key))
+                        this.featureImportances[key] = data["FeatureImportances"][key] ? TupleOfDoubleAndDouble.fromJS(data["FeatureImportances"][key]) : new TupleOfDoubleAndDouble();
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): FeatureImportanceResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new FeatureImportanceResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.featureImportances) {
+            data["FeatureImportances"] = {};
+            for (let key in this.featureImportances) {
+                if (this.featureImportances.hasOwnProperty(key))
+                    data["FeatureImportances"][key] = this.featureImportances[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IFeatureImportanceResult extends IResult {
+    featureImportances?: { [key: string]: TupleOfDoubleAndDouble; } | undefined;
+}
+
+export class TupleOfDoubleAndDouble implements ITupleOfDoubleAndDouble {
+    item1?: number | undefined;
+    item2?: number | undefined;
+
+    constructor(data?: ITupleOfDoubleAndDouble) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.item1 = data["Item1"];
+            this.item2 = data["Item2"];
+        }
+    }
+
+    static fromJS(data: any): TupleOfDoubleAndDouble {
+        data = typeof data === 'object' ? data : {};
+        let result = new TupleOfDoubleAndDouble();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Item1"] = this.item1;
+        data["Item2"] = this.item2;
+        return data;
+    }
+}
+
+export interface ITupleOfDoubleAndDouble {
+    item1?: number | undefined;
+    item2?: number | undefined;
+}
+
+export class PrimitiveStepDescription extends StepDescription implements IPrimitiveStepDescription {
+    hyperparams?: { [key: string]: Value; } | undefined;
+
+    constructor(data?: IPrimitiveStepDescription) {
+        super(data);
+        this._discriminator = "PrimitiveStepDescription";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Hyperparams"]) {
+                this.hyperparams = {};
+                for (let key in data["Hyperparams"]) {
+                    if (data["Hyperparams"].hasOwnProperty(key))
+                        this.hyperparams[key] = data["Hyperparams"][key] ? Value.fromJS(data["Hyperparams"][key]) : <any>undefined;
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): PrimitiveStepDescription {
+        data = typeof data === 'object' ? data : {};
+        let result = new PrimitiveStepDescription();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.hyperparams) {
+            data["Hyperparams"] = {};
+            for (let key in this.hyperparams) {
+                if (this.hyperparams.hasOwnProperty(key))
+                    data["Hyperparams"][key] = this.hyperparams[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IPrimitiveStepDescription extends IStepDescription {
+    hyperparams?: { [key: string]: Value; } | undefined;
+}
+
+export enum ValueType {
+    VALUE_TYPE_UNDEFINED = 0,
+    RAW = 1,
+    DATASET_URI = 2,
+    CSV_URI = 3,
+    PICKLE_URI = 4,
+    PICKLE_BLOB = 5,
+    PLASMA_ID = 6,
+}
+
+export class DatamartSearchParameters implements IDatamartSearchParameters {
+    adapterName?: string | undefined;
+    queryJson?: string | undefined;
+
+    constructor(data?: IDatamartSearchParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.adapterName = data["AdapterName"];
+            this.queryJson = data["QueryJson"];
+        }
+    }
+
+    static fromJS(data: any): DatamartSearchParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new DatamartSearchParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AdapterName"] = this.adapterName;
+        data["QueryJson"] = this.queryJson;
+        return data;
+    }
+}
+
+export interface IDatamartSearchParameters {
+    adapterName?: string | undefined;
+    queryJson?: string | undefined;
+}
+
+export class DatamartAugmentParameters implements IDatamartAugmentParameters {
+    adapterName?: string | undefined;
+    augmentationJson?: string | undefined;
+    numberOfSamples?: number | undefined;
+    augmentedAdapterName?: string | undefined;
+
+    constructor(data?: IDatamartAugmentParameters) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.adapterName = data["AdapterName"];
+            this.augmentationJson = data["AugmentationJson"];
+            this.numberOfSamples = data["NumberOfSamples"];
+            this.augmentedAdapterName = data["AugmentedAdapterName"];
+        }
+    }
+
+    static fromJS(data: any): DatamartAugmentParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new DatamartAugmentParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["AdapterName"] = this.adapterName;
+        data["AugmentationJson"] = this.augmentationJson;
+        data["NumberOfSamples"] = this.numberOfSamples;
+        data["AugmentedAdapterName"] = this.augmentedAdapterName;
+        return data;
+    }
+}
+
+export interface IDatamartAugmentParameters {
+    adapterName?: string | undefined;
+    augmentationJson?: string | undefined;
+    numberOfSamples?: number | undefined;
+    augmentedAdapterName?: string | undefined;
+}
+
+export class RawDataResult extends DistResult implements IRawDataResult {
+    samples?: { [key: string]: any[]; } | undefined;
+    weightedWords?: { [key: string]: Word[]; } | undefined;
+
+    constructor(data?: IRawDataResult) {
+        super(data);
+        this._discriminator = "RawDataResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Samples"]) {
+                this.samples = {};
+                for (let key in data["Samples"]) {
+                    if (data["Samples"].hasOwnProperty(key))
+                        this.samples[key] = data["Samples"][key] !== undefined ? data["Samples"][key] : [];
+                }
+            }
+            if (data["WeightedWords"]) {
+                this.weightedWords = {};
+                for (let key in data["WeightedWords"]) {
+                    if (data["WeightedWords"].hasOwnProperty(key))
+                        this.weightedWords[key] = data["WeightedWords"][key] ? data["WeightedWords"][key].map((i: any) => Word.fromJS(i)) : [];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): RawDataResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new RawDataResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.samples) {
+            data["Samples"] = {};
+            for (let key in this.samples) {
+                if (this.samples.hasOwnProperty(key))
+                    data["Samples"][key] = this.samples[key];
+            }
+        }
+        if (this.weightedWords) {
+            data["WeightedWords"] = {};
+            for (let key in this.weightedWords) {
+                if (this.weightedWords.hasOwnProperty(key))
+                    data["WeightedWords"][key] = this.weightedWords[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRawDataResult extends IDistResult {
+    samples?: { [key: string]: any[]; } | undefined;
+    weightedWords?: { [key: string]: Word[]; } | undefined;
+}
+
+export class Word implements IWord {
+    text?: string | undefined;
+    occurrences?: number | undefined;
+    stem?: string | undefined;
+    isWordGroup?: boolean | undefined;
+
+    constructor(data?: IWord) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.text = data["Text"];
+            this.occurrences = data["Occurrences"];
+            this.stem = data["Stem"];
+            this.isWordGroup = data["IsWordGroup"];
+        }
+    }
+
+    static fromJS(data: any): Word {
+        data = typeof data === 'object' ? data : {};
+        let result = new Word();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Text"] = this.text;
+        data["Occurrences"] = this.occurrences;
+        data["Stem"] = this.stem;
+        data["IsWordGroup"] = this.isWordGroup;
+        return data;
+    }
+}
+
+export interface IWord {
+    text?: string | undefined;
+    occurrences?: number | undefined;
+    stem?: string | undefined;
+    isWordGroup?: boolean | undefined;
+}
+
+export class SampleOperationParameters extends DistOperationParameters implements ISampleOperationParameters {
+    numSamples?: number | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    brushes?: string[] | undefined;
+
+    constructor(data?: ISampleOperationParameters) {
+        super(data);
+        this._discriminator = "SampleOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.numSamples = data["NumSamples"];
+            if (data["AttributeParameters"] && data["AttributeParameters"].constructor === Array) {
+                this.attributeParameters = [];
+                for (let item of data["AttributeParameters"])
+                    this.attributeParameters.push(AttributeParameters.fromJS(item));
+            }
+            if (data["Brushes"] && data["Brushes"].constructor === Array) {
+                this.brushes = [];
+                for (let item of data["Brushes"])
+                    this.brushes.push(item);
+            }
+        }
+    }
+
+    static fromJS(data: any): SampleOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new SampleOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["NumSamples"] = this.numSamples;
+        if (this.attributeParameters && this.attributeParameters.constructor === Array) {
+            data["AttributeParameters"] = [];
+            for (let item of this.attributeParameters)
+                data["AttributeParameters"].push(item.toJSON());
+        }
+        if (this.brushes && this.brushes.constructor === Array) {
+            data["Brushes"] = [];
+            for (let item of this.brushes)
+                data["Brushes"].push(item);
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISampleOperationParameters extends IDistOperationParameters {
+    numSamples?: number | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    brushes?: string[] | undefined;
+}
+
+export class SampleResult extends DistResult implements ISampleResult {
+    samples?: { [key: string]: { [key: string]: number; }; } | undefined;
+    isTruncated?: boolean | undefined;
+
+    constructor(data?: ISampleResult) {
+        super(data);
+        this._discriminator = "SampleResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Samples"]) {
+                this.samples = {};
+                for (let key in data["Samples"]) {
+                    if (data["Samples"].hasOwnProperty(key))
+                        this.samples[key] = data["Samples"][key] !== undefined ? data["Samples"][key] : {};
+                }
+            }
+            this.isTruncated = data["IsTruncated"];
+        }
+    }
+
+    static fromJS(data: any): SampleResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new SampleResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.samples) {
+            data["Samples"] = {};
+            for (let key in this.samples) {
+                if (this.samples.hasOwnProperty(key))
+                    data["Samples"][key] = this.samples[key];
+            }
+        }
+        data["IsTruncated"] = this.isTruncated;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ISampleResult extends IDistResult {
+    samples?: { [key: string]: { [key: string]: number; }; } | undefined;
+    isTruncated?: boolean | undefined;
+}
+
+export class ResultParameters extends UniqueJson implements IResultParameters {
+    operationReference?: IOperationReference | undefined;
+    stopOperation?: boolean | undefined;
+
+    protected _discriminator: string;
+
+    constructor(data?: IResultParameters) {
+        super(data);
+        this._discriminator = "ResultParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.operationReference = data["OperationReference"] ? IOperationReference.fromJS(data["OperationReference"]) : <any>undefined;
+            this.stopOperation = data["StopOperation"];
+        }
+    }
+
+    static fromJS(data: any): ResultParameters {
+        data = typeof data === 'object' ? data : {};
+        if (data["discriminator"] === "RecommenderResultParameters") {
+            let result = new RecommenderResultParameters();
+            result.init(data);
+            return result;
+        }
+        let result = new ResultParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["discriminator"] = this._discriminator;
+        data["OperationReference"] = this.operationReference ? this.operationReference.toJSON() : <any>undefined;
+        data["StopOperation"] = this.stopOperation;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IResultParameters extends IUniqueJson {
+    operationReference?: IOperationReference | undefined;
+    stopOperation?: boolean | undefined;
+}
+
+export class RecommenderResultParameters extends ResultParameters implements IRecommenderResultParameters {
+    from?: number | undefined;
+    to?: number | undefined;
+    pValueSorting?: Sorting | undefined;
+    effectSizeFilter?: EffectSize | undefined;
+
+    constructor(data?: IRecommenderResultParameters) {
+        super(data);
+        this._discriminator = "RecommenderResultParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.from = data["From"];
+            this.to = data["To"];
+            this.pValueSorting = data["PValueSorting"];
+            this.effectSizeFilter = data["EffectSizeFilter"];
+        }
+    }
+
+    static fromJS(data: any): RecommenderResultParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new RecommenderResultParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["From"] = this.from;
+        data["To"] = this.to;
+        data["PValueSorting"] = this.pValueSorting;
+        data["EffectSizeFilter"] = this.effectSizeFilter;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRecommenderResultParameters extends IResultParameters {
+    from?: number | undefined;
+    to?: number | undefined;
+    pValueSorting?: Sorting | undefined;
+    effectSizeFilter?: EffectSize | undefined;
+}
+
+export enum Sorting {
+    Ascending = "Ascending",
+    Descending = "Descending",
+}
+
+export class AddComparisonParameters extends ModelOperationParameters implements IAddComparisonParameters {
+    modelId?: ModelId | undefined;
+    comparisonOrder?: number | undefined;
+    childOperationParameters?: OperationParameters[] | undefined;
+    isCachable?: boolean | undefined;
+
+    constructor(data?: IAddComparisonParameters) {
+        super(data);
+        this._discriminator = "AddComparisonParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.modelId = data["ModelId"] ? ModelId.fromJS(data["ModelId"]) : <any>undefined;
+            this.comparisonOrder = data["ComparisonOrder"];
+            if (data["ChildOperationParameters"] && data["ChildOperationParameters"].constructor === Array) {
+                this.childOperationParameters = [];
+                for (let item of data["ChildOperationParameters"])
+                    this.childOperationParameters.push(OperationParameters.fromJS(item));
+            }
+            this.isCachable = data["IsCachable"];
+        }
+    }
+
+    static fromJS(data: any): AddComparisonParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new AddComparisonParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ModelId"] = this.modelId ? this.modelId.toJSON() : <any>undefined;
+        data["ComparisonOrder"] = this.comparisonOrder;
+        if (this.childOperationParameters && this.childOperationParameters.constructor === Array) {
+            data["ChildOperationParameters"] = [];
+            for (let item of this.childOperationParameters)
+                data["ChildOperationParameters"].push(item.toJSON());
+        }
+        data["IsCachable"] = this.isCachable;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IAddComparisonParameters extends IModelOperationParameters {
+    modelId?: ModelId | undefined;
+    comparisonOrder?: number | undefined;
+    childOperationParameters?: OperationParameters[] | undefined;
+    isCachable?: boolean | undefined;
+}
+
+export class CDFResult extends DistResult implements ICDFResult {
+    cDF?: { [key: string]: number; } | undefined;
+
+    constructor(data?: ICDFResult) {
+        super(data);
+        this._discriminator = "CDFResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["CDF"]) {
+                this.cDF = {};
+                for (let key in data["CDF"]) {
+                    if (data["CDF"].hasOwnProperty(key))
+                        this.cDF[key] = data["CDF"][key];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): CDFResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new CDFResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.cDF) {
+            data["CDF"] = {};
+            for (let key in this.cDF) {
+                if (this.cDF.hasOwnProperty(key))
+                    data["CDF"][key] = this.cDF[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICDFResult extends IDistResult {
+    cDF?: { [key: string]: number; } | undefined;
+}
+
+export class ChiSquaredTestResult extends HypothesisTestResult implements IChiSquaredTestResult {
+    hs_aligned?: TupleOfDoubleAndDouble[] | undefined;
+
+    constructor(data?: IChiSquaredTestResult) {
+        super(data);
+        this._discriminator = "ChiSquaredTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["hs_aligned"] && data["hs_aligned"].constructor === Array) {
+                this.hs_aligned = [];
+                for (let item of data["hs_aligned"])
+                    this.hs_aligned.push(TupleOfDoubleAndDouble.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): ChiSquaredTestResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new ChiSquaredTestResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.hs_aligned && this.hs_aligned.constructor === Array) {
+            data["hs_aligned"] = [];
+            for (let item of this.hs_aligned)
+                data["hs_aligned"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IChiSquaredTestResult extends IHypothesisTestResult {
+    hs_aligned?: TupleOfDoubleAndDouble[] | undefined;
+}
+
+export class CorrelationTestResult extends HypothesisTestResult implements ICorrelationTestResult {
+    degreeOfFreedom?: number | undefined;
+    sampleCorrelationCoefficient?: number | undefined;
+    distResult?: EmpiricalDistResult | undefined;
+
+    constructor(data?: ICorrelationTestResult) {
+        super(data);
+        this._discriminator = "CorrelationTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.degreeOfFreedom = data["DegreeOfFreedom"];
+            this.sampleCorrelationCoefficient = data["SampleCorrelationCoefficient"];
+            this.distResult = data["DistResult"] ? EmpiricalDistResult.fromJS(data["DistResult"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): CorrelationTestResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new CorrelationTestResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["DegreeOfFreedom"] = this.degreeOfFreedom;
+        data["SampleCorrelationCoefficient"] = this.sampleCorrelationCoefficient;
+        data["DistResult"] = this.distResult ? this.distResult.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ICorrelationTestResult extends IHypothesisTestResult {
+    degreeOfFreedom?: number | undefined;
+    sampleCorrelationCoefficient?: number | undefined;
+    distResult?: EmpiricalDistResult | undefined;
+}
+
+export class EmpiricalDistResult extends DistResult implements IEmpiricalDistResult {
+    marginals?: AttributeParameters[] | undefined;
+    marginalDistParameters?: { [key: string]: DistParameter; } | undefined;
+    jointDistParameter?: JointDistParameter | undefined;
+
+    constructor(data?: IEmpiricalDistResult) {
+        super(data);
+        this._discriminator = "EmpiricalDistResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["Marginals"] && data["Marginals"].constructor === Array) {
+                this.marginals = [];
+                for (let item of data["Marginals"])
+                    this.marginals.push(AttributeParameters.fromJS(item));
+            }
+            if (data["MarginalDistParameters"]) {
+                this.marginalDistParameters = {};
+                for (let key in data["MarginalDistParameters"]) {
+                    if (data["MarginalDistParameters"].hasOwnProperty(key))
+                        this.marginalDistParameters[key] = data["MarginalDistParameters"][key] ? DistParameter.fromJS(data["MarginalDistParameters"][key]) : new DistParameter();
+                }
+            }
+            this.jointDistParameter = data["JointDistParameter"] ? JointDistParameter.fromJS(data["JointDistParameter"]) : <any>undefined;
+        }
+    }
+
+    static fromJS(data: any): EmpiricalDistResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new EmpiricalDistResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.marginals && this.marginals.constructor === Array) {
+            data["Marginals"] = [];
+            for (let item of this.marginals)
+                data["Marginals"].push(item.toJSON());
+        }
+        if (this.marginalDistParameters) {
+            data["MarginalDistParameters"] = {};
+            for (let key in this.marginalDistParameters) {
+                if (this.marginalDistParameters.hasOwnProperty(key))
+                    data["MarginalDistParameters"][key] = this.marginalDistParameters[key];
+            }
+        }
+        data["JointDistParameter"] = this.jointDistParameter ? this.jointDistParameter.toJSON() : <any>undefined;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IEmpiricalDistResult extends IDistResult {
+    marginals?: AttributeParameters[] | undefined;
+    marginalDistParameters?: { [key: string]: DistParameter; } | undefined;
+    jointDistParameter?: JointDistParameter | undefined;
+}
+
+export class DistParameter implements IDistParameter {
+    mean?: number | undefined;
+    moment2?: number | undefined;
+    variance?: number | undefined;
+    varianceEstimate?: number | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+
+    constructor(data?: IDistParameter) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.mean = data["Mean"];
+            this.moment2 = data["Moment2"];
+            this.variance = data["Variance"];
+            this.varianceEstimate = data["VarianceEstimate"];
+            this.min = data["Min"];
+            this.max = data["Max"];
+        }
+    }
+
+    static fromJS(data: any): DistParameter {
+        data = typeof data === 'object' ? data : {};
+        let result = new DistParameter();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Mean"] = this.mean;
+        data["Moment2"] = this.moment2;
+        data["Variance"] = this.variance;
+        data["VarianceEstimate"] = this.varianceEstimate;
+        data["Min"] = this.min;
+        data["Max"] = this.max;
+        return data;
+    }
+}
+
+export interface IDistParameter {
+    mean?: number | undefined;
+    moment2?: number | undefined;
+    variance?: number | undefined;
+    varianceEstimate?: number | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+}
+
+export class JointDistParameter implements IJointDistParameter {
+    jointDist?: DistParameter | undefined;
+    covariance?: number | undefined;
+
+    constructor(data?: IJointDistParameter) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.jointDist = data["JointDist"] ? DistParameter.fromJS(data["JointDist"]) : <any>undefined;
+            this.covariance = data["Covariance"];
+        }
+    }
+
+    static fromJS(data: any): JointDistParameter {
+        data = typeof data === 'object' ? data : {};
+        let result = new JointDistParameter();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["JointDist"] = this.jointDist ? this.jointDist.toJSON() : <any>undefined;
+        data["Covariance"] = this.covariance;
+        return data;
+    }
+}
+
+export interface IJointDistParameter {
+    jointDist?: DistParameter | undefined;
+    covariance?: number | undefined;
+}
+
+export enum DistributionType {
+    Continuous = 0,
+    Discrete = 1,
+}
+
+export abstract class DistributionTypeExtension implements IDistributionTypeExtension {
+
+    constructor(data?: IDistributionTypeExtension) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): DistributionTypeExtension {
+        data = typeof data === 'object' ? data : {};
+        throw new Error("The abstract class 'DistributionTypeExtension' cannot be instantiated.");
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        return data;
+    }
+}
+
+export interface IDistributionTypeExtension {
+}
+
+export class GetModelStateParameters extends ModelOperationParameters implements IGetModelStateParameters {
+    modelId?: ModelId | undefined;
+    comparisonIds?: ComparisonId[] | undefined;
+    riskControlType?: RiskControlType | undefined;
+
+    constructor(data?: IGetModelStateParameters) {
+        super(data);
+        this._discriminator = "GetModelStateParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.modelId = data["ModelId"] ? ModelId.fromJS(data["ModelId"]) : <any>undefined;
+            if (data["ComparisonIds"] && data["ComparisonIds"].constructor === Array) {
+                this.comparisonIds = [];
+                for (let item of data["ComparisonIds"])
+                    this.comparisonIds.push(ComparisonId.fromJS(item));
+            }
+            this.riskControlType = data["RiskControlType"];
+        }
+    }
+
+    static fromJS(data: any): GetModelStateParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new GetModelStateParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ModelId"] = this.modelId ? this.modelId.toJSON() : <any>undefined;
+        if (this.comparisonIds && this.comparisonIds.constructor === Array) {
+            data["ComparisonIds"] = [];
+            for (let item of this.comparisonIds)
+                data["ComparisonIds"].push(item.toJSON());
+        }
+        data["RiskControlType"] = this.riskControlType;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IGetModelStateParameters extends IModelOperationParameters {
+    modelId?: ModelId | undefined;
+    comparisonIds?: ComparisonId[] | undefined;
+    riskControlType?: RiskControlType | undefined;
+}
+
+export class KSTestResult extends HypothesisTestResult implements IKSTestResult {
+
+    constructor(data?: IKSTestResult) {
+        super(data);
+        this._discriminator = "KSTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): KSTestResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new KSTestResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IKSTestResult extends IHypothesisTestResult {
+}
+
+export class ModelWealthParameters extends UniqueJson implements IModelWealthParameters {
+    modelId?: ModelId | undefined;
+    riskControlType?: RiskControlType | undefined;
+
+    constructor(data?: IModelWealthParameters) {
+        super(data);
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.modelId = data["ModelId"] ? ModelId.fromJS(data["ModelId"]) : <any>undefined;
+            this.riskControlType = data["RiskControlType"];
+        }
+    }
+
+    static fromJS(data: any): ModelWealthParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new ModelWealthParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["ModelId"] = this.modelId ? this.modelId.toJSON() : <any>undefined;
+        data["RiskControlType"] = this.riskControlType;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IModelWealthParameters extends IUniqueJson {
+    modelId?: ModelId | undefined;
+    riskControlType?: RiskControlType | undefined;
+}
+
+export class RootMeanSquareTestResult extends HypothesisTestResult implements IRootMeanSquareTestResult {
+    simulationCount?: number | undefined;
+    extremeSimulationCount?: number | undefined;
+
+    constructor(data?: IRootMeanSquareTestResult) {
+        super(data);
+        this._discriminator = "RootMeanSquareTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.simulationCount = data["SimulationCount"];
+            this.extremeSimulationCount = data["ExtremeSimulationCount"];
+        }
+    }
+
+    static fromJS(data: any): RootMeanSquareTestResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new RootMeanSquareTestResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["SimulationCount"] = this.simulationCount;
+        data["ExtremeSimulationCount"] = this.extremeSimulationCount;
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IRootMeanSquareTestResult extends IHypothesisTestResult {
+    simulationCount?: number | undefined;
+    extremeSimulationCount?: number | undefined;
+}
+
+export class TTestResult extends HypothesisTestResult implements ITTestResult {
+    degreeOfFreedom?: number | undefined;
+    distResults?: EmpiricalDistResult[] | undefined;
+
+    constructor(data?: ITTestResult) {
+        super(data);
+        this._discriminator = "TTestResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.degreeOfFreedom = data["DegreeOfFreedom"];
+            if (data["DistResults"] && data["DistResults"].constructor === Array) {
+                this.distResults = [];
+                for (let item of data["DistResults"])
+                    this.distResults.push(EmpiricalDistResult.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): TTestResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new TTestResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["DegreeOfFreedom"] = this.degreeOfFreedom;
+        if (this.distResults && this.distResults.constructor === Array) {
+            data["DistResults"] = [];
+            for (let item of this.distResults)
+                data["DistResults"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface ITTestResult extends IHypothesisTestResult {
+    degreeOfFreedom?: number | undefined;
+    distResults?: EmpiricalDistResult[] | undefined;
+}
+
+export enum Sorting2 {
+    Ascending = 0,
+    Descending = 1,
+}
+
+export class BinLabel implements IBinLabel {
+    value?: number | undefined;
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    label?: string | undefined;
+
+    constructor(data?: IBinLabel) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.value = data["Value"];
+            this.minValue = data["MinValue"];
+            this.maxValue = data["MaxValue"];
+            this.label = data["Label"];
+        }
+    }
+
+    static fromJS(data: any): BinLabel {
+        data = typeof data === 'object' ? data : {};
+        let result = new BinLabel();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        data["MinValue"] = this.minValue;
+        data["MaxValue"] = this.maxValue;
+        data["Label"] = this.label;
+        return data;
+    }
+}
+
+export interface IBinLabel {
+    value?: number | undefined;
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    label?: string | undefined;
+}
+
+export class PreProcessedString implements IPreProcessedString {
+    value?: string | undefined;
+    id?: number | undefined;
+    stringLookup?: { [key: string]: number; } | undefined;
+    indexLookup?: { [key: string]: string; } | undefined;
+
+    constructor(data?: IPreProcessedString) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.value = data["Value"];
+            this.id = data["Id"];
+            if (data["StringLookup"]) {
+                this.stringLookup = {};
+                for (let key in data["StringLookup"]) {
+                    if (data["StringLookup"].hasOwnProperty(key))
+                        this.stringLookup[key] = data["StringLookup"][key];
+                }
+            }
+            if (data["IndexLookup"]) {
+                this.indexLookup = {};
+                for (let key in data["IndexLookup"]) {
+                    if (data["IndexLookup"].hasOwnProperty(key))
+                        this.indexLookup[key] = data["IndexLookup"][key];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): PreProcessedString {
+        data = typeof data === 'object' ? data : {};
+        let result = new PreProcessedString();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Value"] = this.value;
+        data["Id"] = this.id;
+        if (this.stringLookup) {
+            data["StringLookup"] = {};
+            for (let key in this.stringLookup) {
+                if (this.stringLookup.hasOwnProperty(key))
+                    data["StringLookup"][key] = this.stringLookup[key];
+            }
+        }
+        if (this.indexLookup) {
+            data["IndexLookup"] = {};
+            for (let key in this.indexLookup) {
+                if (this.indexLookup.hasOwnProperty(key))
+                    data["IndexLookup"][key] = this.indexLookup[key];
+            }
+        }
+        return data;
+    }
+}
+
+export interface IPreProcessedString {
+    value?: string | undefined;
+    id?: number | undefined;
+    stringLookup?: { [key: string]: number; } | undefined;
+    indexLookup?: { [key: string]: string; } | undefined;
+}
+
+export class BitSet implements IBitSet {
+    length?: number | undefined;
+    size?: number | undefined;
+
+    constructor(data?: IBitSet) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+            this.length = data["Length"];
+            this.size = data["Size"];
+        }
+    }
+
+    static fromJS(data: any): BitSet {
+        data = typeof data === 'object' ? data : {};
+        let result = new BitSet();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Length"] = this.length;
+        data["Size"] = this.size;
+        return data;
+    }
+}
+
+export interface IBitSet {
+    length?: number | undefined;
+    size?: number | undefined;
+}
+
+export class DateTimeUtil implements IDateTimeUtil {
+
+    constructor(data?: IDateTimeUtil) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(data?: any) {
+        if (data) {
+        }
+    }
+
+    static fromJS(data: any): DateTimeUtil {
+        data = typeof data === 'object' ? data : {};
+        let result = new DateTimeUtil();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        return data;
+    }
+}
+
+export interface IDateTimeUtil {
+}
+
+export class FrequentItemsetOperationParameters extends DistOperationParameters implements IFrequentItemsetOperationParameters {
+    filter?: string | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    attributeCodeParameters?: AttributeCaclculatedParameters[] | undefined;
+
+    constructor(data?: IFrequentItemsetOperationParameters) {
+        super(data);
+        this._discriminator = "FrequentItemsetOperationParameters";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            this.filter = data["Filter"];
+            if (data["AttributeParameters"] && data["AttributeParameters"].constructor === Array) {
+                this.attributeParameters = [];
+                for (let item of data["AttributeParameters"])
+                    this.attributeParameters.push(AttributeParameters.fromJS(item));
+            }
+            if (data["AttributeCodeParameters"] && data["AttributeCodeParameters"].constructor === Array) {
+                this.attributeCodeParameters = [];
+                for (let item of data["AttributeCodeParameters"])
+                    this.attributeCodeParameters.push(AttributeCaclculatedParameters.fromJS(item));
+            }
+        }
+    }
+
+    static fromJS(data: any): FrequentItemsetOperationParameters {
+        data = typeof data === 'object' ? data : {};
+        let result = new FrequentItemsetOperationParameters();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["Filter"] = this.filter;
+        if (this.attributeParameters && this.attributeParameters.constructor === Array) {
+            data["AttributeParameters"] = [];
+            for (let item of this.attributeParameters)
+                data["AttributeParameters"].push(item.toJSON());
+        }
+        if (this.attributeCodeParameters && this.attributeCodeParameters.constructor === Array) {
+            data["AttributeCodeParameters"] = [];
+            for (let item of this.attributeCodeParameters)
+                data["AttributeCodeParameters"].push(item.toJSON());
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IFrequentItemsetOperationParameters extends IDistOperationParameters {
+    filter?: string | undefined;
+    attributeParameters?: AttributeParameters[] | undefined;
+    attributeCodeParameters?: AttributeCaclculatedParameters[] | undefined;
+}
+
+export class FrequentItemsetResult extends Result implements IFrequentItemsetResult {
+    frequentItems?: { [key: string]: number; } | undefined;
+
+    constructor(data?: IFrequentItemsetResult) {
+        super(data);
+        this._discriminator = "FrequentItemsetResult";
+    }
+
+    init(data?: any) {
+        super.init(data);
+        if (data) {
+            if (data["FrequentItems"]) {
+                this.frequentItems = {};
+                for (let key in data["FrequentItems"]) {
+                    if (data["FrequentItems"].hasOwnProperty(key))
+                        this.frequentItems[key] = data["FrequentItems"][key];
+                }
+            }
+        }
+    }
+
+    static fromJS(data: any): FrequentItemsetResult {
+        data = typeof data === 'object' ? data : {};
+        let result = new FrequentItemsetResult();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        if (this.frequentItems) {
+            data["FrequentItems"] = {};
+            for (let key in this.frequentItems) {
+                if (this.frequentItems.hasOwnProperty(key))
+                    data["FrequentItems"][key] = this.frequentItems[key];
+            }
+        }
+        super.toJSON(data);
+        return data;
+    }
+}
+
+export interface IFrequentItemsetResult extends IResult {
+    frequentItems?: { [key: string]: number; } | undefined;
+}
+
diff --git a/src/client/northstar/operations/BaseOperation.ts b/src/client/northstar/operations/BaseOperation.ts
new file mode 100644
index 000000000..f545b2c58
--- /dev/null
+++ b/src/client/northstar/operations/BaseOperation.ts
@@ -0,0 +1,178 @@
+import { FilterModel } from '../core/filter/FilterModel'
+import { ErrorResult, Exception, OperationParameters, OperationReference, Result, ResultParameters } from '../model/idea/idea';
+import { action, computed, observable } from "mobx";
+import { Gateway } from '../manager/Gateway';
+
+export abstract class BaseOperation {
+    private _interactionTimeoutId: number = 0;
+    private static _currentOperations: Map<number, PollPromise> = new Map<number, PollPromise>();
+    //public InteractionTimeout: EventDelegate<InteractionTimeoutEventArgs> = new EventDelegate<InteractionTimeoutEventArgs>();
+
+    @observable public Error: string = "";
+    @observable public OverridingFilters: FilterModel[] = [];
+    //@observable 
+    @observable public Result?: Result = undefined;
+    @observable public ComputationStarted: boolean = false;
+    public OperationReference?: OperationReference = undefined;
+
+    private static _nextId = 0;
+    public RequestSalt: string = "";
+    public Id: number;
+
+    constructor() {
+        this.Id = BaseOperation._nextId++;
+    }
+
+    @computed
+    public get FilterString(): string {
+
+        // let filterModels: FilterModel[] = [];
+        // return FilterModel.GetFilterModelsRecursive(this, new Set<GraphNode<BaseOperationViewModel, FilterLinkViewModel>>(), filterModels, true)
+        // if (this.OverridingFilters.length > 0) {
+        //     return "(" + this.OverridingFilters.filter(fm => fm != null).map(fm => fm.ToPythonString()).join(" || ") + ")";
+        // }
+        // let rdg = MainManager.Instance.MainViewModel.FilterReverseDependencyGraph;
+        // let sliceModel = this.TypedViewModel.IncomingSliceModel;
+        // if (sliceModel != null && sliceModel.Source != null && instanceOfIBaseFilterProvider(sliceModel.Source) && rdg.has(sliceModel.Source)) {
+        //     let filterModels = sliceModel.Source.FilterModels.map(f => f);
+        //     return FilterModel.GetFilterModelsRecursive(rdg.get(sliceModel.Source), new Set<GraphNode<BaseOperationViewModel, FilterLinkViewModel>>(), filterModels, false);
+        // }
+
+        // if (rdg.has(this.TypedViewModel)) {
+        //     let filterModels = [];
+        //     return FilterModel.GetFilterModelsRecursive(rdg.get(this.TypedViewModel), new Set<GraphNode<BaseOperationViewModel, FilterLinkViewModel>>(), filterModels, true)
+        // }
+        return "";
+    }
+
+
+    @action
+    public SetResult(result: Result): void {
+        this.Result = result;
+    }
+
+    public async Update(): Promise<void> {
+
+        try {
+            if (BaseOperation._currentOperations.has(this.Id)) {
+                BaseOperation._currentOperations.get(this.Id)!.Cancel();
+                if (this.OperationReference) {
+                    Gateway.Instance.PauseOperation(this.OperationReference.toJSON());
+                }
+            }
+
+            let operationParameters = this.CreateOperationParameters();
+            if (this.Result)
+                this.Result.progress = 0; // bcz: used to set Result to undefined, but that causes the display to blink
+            this.Error = "";
+            let salt = Math.random().toString();
+            this.RequestSalt = salt;
+
+            if (!operationParameters) {
+                this.ComputationStarted = false;
+                return;
+            }
+
+            this.ComputationStarted = true;
+            //let start = performance.now();
+            let promise = Gateway.Instance.StartOperation(operationParameters.toJSON());
+            promise.catch(err => {
+                action(() => {
+                    this.Error = err;
+                    console.error(err);
+                });
+            });
+            let operationReference = await promise;
+
+
+            if (operationReference) {
+                this.OperationReference = operationReference;
+
+                let resultParameters = new ResultParameters();
+                resultParameters.operationReference = operationReference;
+
+                let pollPromise = new PollPromise(salt, operationReference);
+                BaseOperation._currentOperations.set(this.Id, pollPromise);
+
+                pollPromise.Start(async () => {
+                    let result = await Gateway.Instance.GetResult(resultParameters.toJSON());
+                    if (result instanceof ErrorResult) {
+                        throw new Error((result as ErrorResult).message);
+                    }
+                    if (this.RequestSalt == pollPromise.RequestSalt) {
+                        if (result && (!this.Result || this.Result.progress != result.progress)) {
+                            /*if (operationViewModel.Result !== null && operationViewModel.Result !== undefined) {
+                                let t1 = performance.now();
+                                console.log((t1 - start) + " milliseconds.");
+                                start = performance.now();
+                            }*/
+                            this.SetResult(result);
+                        }
+
+                        if (!result || result.progress! < 1) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }, 100).catch((err: Error) => action(() => {
+                    this.Error = err.message;
+                    console.error(err.message);
+                })()
+                );
+            }
+        }
+        catch (err) {
+            console.error(err as Exception);
+            // ErrorDialog.Instance.HandleError(err, operationViewModel);
+        }
+    }
+
+    public CreateOperationParameters(): OperationParameters | undefined { return undefined; }
+
+    private interactionTimeout() {
+        // clearTimeout(this._interactionTimeoutId);
+        // this.InteractionTimeout.Fire(new InteractionTimeoutEventArgs(this.TypedViewModel, InteractionTimeoutType.Timeout));
+    }
+}
+
+export class PollPromise {
+    public RequestSalt: string;
+    public OperationReference: OperationReference;
+
+    private _notCanceled: boolean = true;
+    private _poll: undefined | (() => Promise<boolean>);
+    private _delay: number = 0;
+
+    public constructor(requestKey: string, operationReference: OperationReference) {
+        this.RequestSalt = requestKey;
+        this.OperationReference = operationReference;
+    }
+
+    public Cancel(): void {
+        this._notCanceled = false;
+    }
+
+    public Start(poll: () => Promise<boolean>, delay: number): Promise<void> {
+        this._poll = poll;
+        this._delay = delay;
+        return this.pollRecursive();
+    }
+
+    private pollRecursive = (): Promise<void> => {
+        return Promise.resolve().then(this._poll).then((flag) => {
+            this._notCanceled && flag && new Promise((res) => (setTimeout(res, this._delay)))
+                .then(this.pollRecursive);
+        });
+    }
+}
+
+
+export class InteractionTimeoutEventArgs {
+    constructor(public Sender: object, public Type: InteractionTimeoutType) {
+    }
+}
+
+export enum InteractionTimeoutType {
+    Reset = 0,
+    Timeout = 1
+}
diff --git a/src/client/northstar/operations/HistogramOperation.ts b/src/client/northstar/operations/HistogramOperation.ts
new file mode 100644
index 000000000..e63de1632
--- /dev/null
+++ b/src/client/northstar/operations/HistogramOperation.ts
@@ -0,0 +1,124 @@
+import { action, computed, observable, trace } from "mobx";
+import { Document } from "../../../fields/Document";
+import { FieldWaiting } from "../../../fields/Field";
+import { KeyStore } from "../../../fields/KeyStore";
+import { CurrentUserUtils } from "../../../server/authentication/models/current_user_utils";
+import { ColumnAttributeModel } from "../core/attribute/AttributeModel";
+import { AttributeTransformationModel } from "../core/attribute/AttributeTransformationModel";
+import { CalculatedAttributeManager } from "../core/attribute/CalculatedAttributeModel";
+import { FilterModel } from "../core/filter/FilterModel";
+import { FilterOperand } from "../core/filter/FilterOperand";
+import { IBaseFilterConsumer } from "../core/filter/IBaseFilterConsumer";
+import { IBaseFilterProvider } from "../core/filter/IBaseFilterProvider";
+import { HistogramField } from "../dash-fields/HistogramField";
+import { SETTINGS_SAMPLE_SIZE, SETTINGS_X_BINS, SETTINGS_Y_BINS } from "../model/binRanges/VisualBinRangeHelper";
+import { AggregateFunction, AggregateParameters, Attribute, AverageAggregateParameters, Bin, DataType, DoubleValueAggregateResult, HistogramOperationParameters, HistogramResult, QuantitativeBinRange } from "../model/idea/idea";
+import { ModelHelpers } from "../model/ModelHelpers";
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { BaseOperation } from "./BaseOperation";
+
+export class HistogramOperation extends BaseOperation implements IBaseFilterConsumer, IBaseFilterProvider {
+    public static Empty = new HistogramOperation("-empty schema-", new AttributeTransformationModel(new ColumnAttributeModel(new Attribute())), new AttributeTransformationModel(new ColumnAttributeModel(new Attribute())), new AttributeTransformationModel(new ColumnAttributeModel(new Attribute())));
+    @observable public FilterOperand: FilterOperand = FilterOperand.AND;
+    @observable public Links: Document[] = [];
+    @observable public BrushLinks: { l: Document, b: Document }[] = [];
+    @observable public BrushColors: number[] = [];
+    @observable public FilterModels: FilterModel[] = [];
+
+    @observable public Normalization: number = -1;
+    @observable public X: AttributeTransformationModel;
+    @observable public Y: AttributeTransformationModel;
+    @observable public V: AttributeTransformationModel;
+    @observable public SchemaName: string;
+    @observable public QRange: QuantitativeBinRange | undefined;
+    @computed public get Schema() { return CurrentUserUtils.GetNorthstarSchema(this.SchemaName); }
+
+    constructor(schemaName: string, x: AttributeTransformationModel, y: AttributeTransformationModel, v: AttributeTransformationModel, normalized?: number) {
+        super();
+        this.X = x;
+        this.Y = y;
+        this.V = v;
+        this.Normalization = normalized ? normalized : -1;
+        this.SchemaName = schemaName;
+    }
+
+    Equals(other: Object): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    @action
+    public AddFilterModels(filterModels: FilterModel[]): void {
+        filterModels.filter(f => f !== null).forEach(fm => this.FilterModels.push(fm));
+    }
+    @action
+    public RemoveFilterModels(filterModels: FilterModel[]): void {
+        ArrayUtil.RemoveMany(this.FilterModels, filterModels);
+    }
+
+    @computed
+    public get FilterString(): string {
+        let filterModels: FilterModel[] = [];
+        return FilterModel.GetFilterModelsRecursive(this, new Set<IBaseFilterProvider>(), filterModels, true)
+    }
+
+    @computed
+    public get BrushString(): string[] {
+        trace();
+        let brushes: string[] = [];
+        this.BrushLinks.map(brushLink => {
+            let brushHistogram = brushLink.b.GetT(KeyStore.Data, HistogramField);
+            if (brushHistogram && brushHistogram != FieldWaiting) {
+                let filterModels: FilterModel[] = [];
+                brushes.push(FilterModel.GetFilterModelsRecursive(brushHistogram.Data, new Set<IBaseFilterProvider>(), filterModels, false));
+            }
+        });
+        return brushes;
+    }
+
+    private getAggregateParameters(histoX: AttributeTransformationModel, histoY: AttributeTransformationModel, histoValue: AttributeTransformationModel) {
+        let allAttributes = new Array<AttributeTransformationModel>(histoX, histoY, histoValue);
+        allAttributes = ArrayUtil.Distinct(allAttributes.filter(a => a.AggregateFunction !== AggregateFunction.None));
+
+        let numericDataTypes = [DataType.Int, DataType.Double, DataType.Float];
+        let perBinAggregateParameters: AggregateParameters[] = ModelHelpers.GetAggregateParametersWithMargins(this.Schema!.distinctAttributeParameters, allAttributes);
+        let globalAggregateParameters: AggregateParameters[] = [];
+        [histoX, histoY]
+            .filter(a => a.AggregateFunction === AggregateFunction.None && ArrayUtil.Contains(numericDataTypes, a.AttributeModel.DataType))
+            .forEach(a => {
+                let avg = new AverageAggregateParameters();
+                avg.attributeParameters = ModelHelpers.GetAttributeParameters(a.AttributeModel);
+                globalAggregateParameters.push(avg);
+            });
+        return [perBinAggregateParameters, globalAggregateParameters];
+    }
+
+    public CreateOperationParameters(): HistogramOperationParameters | undefined {
+        if (this.X && this.Y && this.V) {
+            let [perBinAggregateParameters, globalAggregateParameters] = this.getAggregateParameters(this.X, this.Y, this.V);
+            return new HistogramOperationParameters({
+                enableBrushComputation: true,
+                adapterName: this.SchemaName,
+                filter: this.FilterString,
+                brushes: this.BrushString,
+                binningParameters: [ModelHelpers.GetBinningParameters(this.X, SETTINGS_X_BINS, this.QRange ? this.QRange.minValue : undefined, this.QRange ? this.QRange.maxValue : undefined),
+                ModelHelpers.GetBinningParameters(this.Y, SETTINGS_Y_BINS)],
+                sampleStreamBlockSize: SETTINGS_SAMPLE_SIZE,
+                perBinAggregateParameters: perBinAggregateParameters,
+                globalAggregateParameters: globalAggregateParameters,
+                sortPerBinAggregateParameter: undefined,
+                attributeCalculatedParameters: CalculatedAttributeManager
+                    .AllCalculatedAttributes.map(a => ModelHelpers.GetAttributeParametersFromAttributeModel(a)),
+                degreeOfParallism: 1, // Settings.Instance.DegreeOfParallelism,
+                isCachable: false
+            });
+        }
+    }
+
+    @action
+    public async Update(): Promise<void> {
+        this.BrushColors = this.BrushLinks.map(e => e.l.GetNumber(KeyStore.BackgroundColor, 0));
+        return super.Update();
+    }
+}
+
+
diff --git a/src/client/northstar/utils/ArrayUtil.ts b/src/client/northstar/utils/ArrayUtil.ts
new file mode 100644
index 000000000..f35c98317
--- /dev/null
+++ b/src/client/northstar/utils/ArrayUtil.ts
@@ -0,0 +1,90 @@
+import { Exception } from "../model/idea/idea";
+
+export class ArrayUtil {
+
+    public static Contains(arr1: any[], arr2: any): boolean {
+        if (arr1.length === 0) {
+            return false;
+        }
+        let isComplex = typeof arr1[0] === "object";
+        for (let i = 0; i < arr1.length; i++) {
+            if (isComplex && "Equals" in arr1[i]) {
+                if (arr1[i].Equals(arr2)) {
+                    return true;
+                }
+            }
+            else {
+                if (arr1[i] === arr2) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+
+    public static RemoveMany(arr: any[], elements: Object[]) {
+        elements.forEach(e => ArrayUtil.Remove(arr, e));
+    }
+
+    public static AddMany(arr: any[], others: Object[]) {
+        arr.push(...others);
+    }
+
+    public static Clear(arr: any[]) {
+        arr.splice(0, arr.length);
+    }
+
+
+    public static Remove(arr: any[], other: Object) {
+        const index = ArrayUtil.IndexOfWithEqual(arr, other);
+        if (index === -1) {
+            return;
+        }
+        arr.splice(index, 1);
+    }
+
+
+    public static First<T>(arr: T[], predicate: (x: any) => boolean): T {
+        let filtered = arr.filter(predicate);
+        if (filtered.length > 0) {
+            return filtered[0];
+        }
+        throw new Exception()
+    }
+
+    public static FirstOrDefault<T>(arr: T[], predicate: (x: any) => boolean): T | undefined {
+        let filtered = arr.filter(predicate);
+        if (filtered.length > 0) {
+            return filtered[0];
+        }
+        return undefined;
+    }
+
+    public static Distinct(arr: any[]): any[] {
+        let ret = [];
+        for (let i = 0; i < arr.length; i++) {
+            if (!ArrayUtil.Contains(ret, arr[i])) {
+                ret.push(arr[i]);
+            }
+        }
+        return ret;
+    }
+
+    public static IndexOfWithEqual(arr: any[], other: any): number {
+        for (let i = 0; i < arr.length; i++) {
+            let isComplex = typeof arr[0] === "object";
+            if (isComplex && "Equals" in arr[i]) {
+                if (arr[i].Equals(other)) {
+                    return i;
+                }
+            }
+            else {
+                if (arr[i] === other) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/Extensions.ts b/src/client/northstar/utils/Extensions.ts
new file mode 100644
index 000000000..7c2b7fc9d
--- /dev/null
+++ b/src/client/northstar/utils/Extensions.ts
@@ -0,0 +1,29 @@
+interface String {
+    ReplaceAll(toReplace: string, replacement: string): string;
+    Truncate(length: number, replacement: string): String;
+}
+
+String.prototype.ReplaceAll = function (toReplace: string, replacement: string): string {
+    var target = this;
+    return target.split(toReplace).join(replacement);
+}
+
+String.prototype.Truncate = function (length: number, replacement: string): String {
+    var target = this;
+    if (target.length >= length) {
+        target = target.slice(0, Math.max(0, length - replacement.length)) + replacement;
+    }
+    return target;
+}
+
+interface Math {
+    log10(val: number): number;
+}
+
+Math.log10 = function (val: number): number {
+    return Math.log(val) / Math.LN10;
+}
+
+declare interface ObjectConstructor {
+    assign(...objects: Object[]): Object;
+}
diff --git a/src/client/northstar/utils/GeometryUtil.ts b/src/client/northstar/utils/GeometryUtil.ts
new file mode 100644
index 000000000..d5f3ba631
--- /dev/null
+++ b/src/client/northstar/utils/GeometryUtil.ts
@@ -0,0 +1,129 @@
+import { MathUtil, PIXIRectangle, PIXIPoint } from "./MathUtil";
+
+
+export class GeometryUtil {
+
+    public static ComputeBoundingBox(points: { x: number, y: number }[], scale = 1, padding: number = 0): PIXIRectangle {
+        let minX: number = Number.MAX_VALUE;
+        let minY: number = Number.MAX_VALUE;
+        let maxX: number = Number.MIN_VALUE;
+        let maxY: number = Number.MIN_VALUE;
+        for (var i = 0; i < points.length; i++) {
+            if (points[i].x < minX)
+                minX = points[i].x;
+            if (points[i].y < minY)
+                minY = points[i].y;
+            if (points[i].x > maxX)
+                maxX = points[i].x;
+            if (points[i].y > maxY)
+                maxY = points[i].y;
+        }
+        return new PIXIRectangle(minX * scale - padding, minY * scale - padding, (maxX - minX) * scale + padding * 2, (maxY - minY) * scale + padding * 2);
+    }
+
+    public static RectangleOverlap(rect1: PIXIRectangle, rect2: PIXIRectangle) {
+        let x_overlap = Math.max(0, Math.min(rect1.right, rect2.right) - Math.max(rect1.left, rect2.left));
+        let y_overlap = Math.max(0, Math.min(rect1.bottom, rect2.bottom) - Math.max(rect1.top, rect2.top));
+        return x_overlap * y_overlap;
+    }
+
+    public static RotatePoints(center: { x: number, y: number }, points: { x: number, y: number }[], angle: number): PIXIPoint[] {
+        const rotate = (cx: number, cy: number, x: number, y: number, angle: number) => {
+            const radians = angle,
+                cos = Math.cos(radians),
+                sin = Math.sin(radians),
+                nx = (cos * (x - cx)) + (sin * (y - cy)) + cx,
+                ny = (cos * (y - cy)) - (sin * (x - cx)) + cy;
+            return new PIXIPoint(nx, ny);
+        }
+        return points.map(p => rotate(center.x, center.y, p.x, p.y, angle));
+    }
+
+    public static LineByLeastSquares(points: { x: number, y: number }[]): PIXIPoint[] {
+        let sum_x: number = 0;
+        let sum_y: number = 0;
+        let sum_xy: number = 0;
+        let sum_xx: number = 0;
+        let count: number = 0;
+
+        let x: number = 0;
+        let y: number = 0;
+
+
+        if (points.length === 0) {
+            return [];
+        }
+
+        for (let v = 0; v < points.length; v++) {
+            x = points[v].x;
+            y = points[v].y;
+            sum_x += x;
+            sum_y += y;
+            sum_xx += x * x;
+            sum_xy += x * y;
+            count++;
+        }
+
+        let m = (count * sum_xy - sum_x * sum_y) / (count * sum_xx - sum_x * sum_x);
+        let b = (sum_y / count) - (m * sum_x) / count;
+        let result: PIXIPoint[] = new Array<PIXIPoint>();
+
+        for (let v = 0; v < points.length; v++) {
+            x = points[v].x;
+            y = x * m + b;
+            result.push(new PIXIPoint(x, y));
+        }
+        return result;
+    }
+
+    // public static PointInsidePolygon(vs:Point[], x:number, y:number):boolean {
+    //     // ray-casting algorithm based on
+    //     // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
+
+    //     var inside = false;
+    //     for (var i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+    //         var xi = vs[i].x, yi = vs[i].y;
+    //         var xj = vs[j].x, yj = vs[j].y;
+
+    //         var intersect = ((yi > y) != (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
+    //         if (intersect) 
+    //            inside = !inside;
+    //     }
+
+    //     return inside;
+    // };
+
+    public static IntersectLines(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): boolean {
+        let a1: number, a2: number, b1: number, b2: number, c1: number, c2: number;
+        let r1: number, r2: number, r3: number, r4: number;
+        let denom: number, offset: number, num: number;
+
+        a1 = y2 - y1;
+        b1 = x1 - x2;
+        c1 = (x2 * y1) - (x1 * y2);
+        r3 = ((a1 * x3) + (b1 * y3) + c1);
+        r4 = ((a1 * x4) + (b1 * y4) + c1);
+
+        if ((r3 !== 0) && (r4 !== 0) && (MathUtil.Sign(r3) === MathUtil.Sign(r4))) {
+            return false;
+        }
+
+        a2 = y4 - y3;
+        b2 = x3 - x4;
+        c2 = (x4 * y3) - (x3 * y4);
+
+        r1 = (a2 * x1) + (b2 * y1) + c2;
+        r2 = (a2 * x2) + (b2 * y2) + c2;
+
+        if ((r1 !== 0) && (r2 !== 0) && (MathUtil.Sign(r1) === MathUtil.Sign(r2))) {
+            return false;
+        }
+
+        denom = (a1 * b2) - (a2 * b1);
+
+        if (denom === 0) {
+            return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/IDisposable.ts b/src/client/northstar/utils/IDisposable.ts
new file mode 100644
index 000000000..5e9843326
--- /dev/null
+++ b/src/client/northstar/utils/IDisposable.ts
@@ -0,0 +1,3 @@
+export interface IDisposable {
+    Dispose(): void;
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/IEquatable.ts b/src/client/northstar/utils/IEquatable.ts
new file mode 100644
index 000000000..2f81c2478
--- /dev/null
+++ b/src/client/northstar/utils/IEquatable.ts
@@ -0,0 +1,3 @@
+export interface IEquatable {
+    Equals(other: Object): boolean;
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/KeyCodes.ts b/src/client/northstar/utils/KeyCodes.ts
new file mode 100644
index 000000000..044569ffe
--- /dev/null
+++ b/src/client/northstar/utils/KeyCodes.ts
@@ -0,0 +1,137 @@
+/**
+ * Class contains the keycodes for keys on your keyboard.
+ *
+ * Useful for auto completion:
+ *
+ * ```
+ * switch (event.key)
+ * {
+ *      case KeyCode.UP:
+ *      {
+ *      	// Up key pressed
+ *       	break;
+ *      }
+ *      case KeyCode.DOWN:
+ *      {
+ *      	// Down key pressed
+ *       	break;
+ *      }
+ *      case KeyCode.LEFT:
+ *      {
+ *      	// Left key pressed
+ *       	break;
+ *      }
+ *      case KeyCode.RIGHT:
+ *      {
+ *      	// Right key pressed
+ *       	break;
+ *      }
+ *      default:
+ *      {
+ *      	// ignore
+ *      	break;
+ *      }
+ * }
+ * ```
+ */
+export class KeyCodes
+{
+	public static TAB:number = 9;
+	public static CAPS_LOCK:number = 20;
+	public static SHIFT:number = 16;
+	public static CONTROL:number = 17;
+	public static SPACE:number = 32;
+	public static DOWN:number = 40;
+	public static UP:number = 38;
+	public static LEFT:number = 37;
+	public static RIGHT:number = 39;
+	public static ESCAPE:number = 27;
+	public static F1:number = 112;
+	public static F2:number = 113;
+	public static F3:number = 114;
+	public static F4:number = 115;
+	public static F5:number = 116;
+	public static F6:number = 117;
+	public static F7:number = 118;
+	public static F8:number = 119;
+	public static F9:number = 120;
+	public static F10:number = 121;
+	public static F11:number = 122;
+	public static F12:number = 123;
+	public static INSERT:number = 45;
+	public static HOME:number = 36;
+	public static PAGE_UP:number = 33;
+	public static PAGE_DOWN:number = 34;
+	public static DELETE:number = 46;
+	public static END:number = 35;
+	public static ENTER:number = 13;
+	public static BACKSPACE:number = 8;
+	public static NUMPAD_0:number = 96;
+	public static NUMPAD_1:number = 97;
+	public static NUMPAD_2:number = 98;
+	public static NUMPAD_3:number = 99;
+	public static NUMPAD_4:number = 100;
+	public static NUMPAD_5:number = 101;
+	public static NUMPAD_6:number = 102;
+	public static NUMPAD_7:number = 103;
+	public static NUMPAD_8:number = 104;
+	public static NUMPAD_9:number = 105;
+	public static NUMPAD_DIVIDE:number = 111;
+	public static NUMPAD_ADD:number = 107;
+	public static NUMPAD_ENTER:number = 13;
+	public static NUMPAD_DECIMAL:number = 110;
+	public static NUMPAD_SUBTRACT:number = 109;
+	public static NUMPAD_MULTIPLY:number = 106;
+	public static SEMICOLON:number = 186;
+	public static EQUAL:number = 187;
+	public static COMMA:number = 188;
+	public static MINUS:number = 189;
+	public static PERIOD:number = 190;
+	public static SLASH:number = 191;
+	public static BACKQUOTE:number = 192;
+	public static LEFTBRACKET:number = 219;
+	public static BACKSLASH:number = 220;
+	public static RIGHTBRACKET:number = 221;
+	public static QUOTE:number = 222;
+	public static ALT:number = 18;
+	public static COMMAND:number = 15;
+	public static NUMPAD:number = 21;
+	public static A:number = 65;
+	public static B:number = 66;
+	public static C:number = 67;
+	public static D:number = 68;
+	public static E:number = 69;
+	public static F:number = 70;
+	public static G:number = 71;
+	public static H:number = 72;
+	public static I:number = 73;
+	public static J:number = 74;
+	public static K:number = 75;
+	public static L:number = 76;
+	public static M:number = 77;
+	public static N:number = 78;
+	public static O:number = 79;
+	public static P:number = 80;
+	public static Q:number = 81;
+	public static R:number = 82;
+	public static S:number = 83;
+	public static T:number = 84;
+	public static U:number = 85;
+	public static V:number = 86;
+	public static W:number = 87;
+	public static X:number = 88;
+	public static Y:number = 89;
+	public static Z:number = 90;
+	public static NUM_0:number = 48;
+	public static NUM_1:number = 49;
+	public static NUM_2:number = 50;
+	public static NUM_3:number = 51;
+	public static NUM_4:number = 52;
+	public static NUM_5:number = 53;
+	public static NUM_6:number = 54;
+	public static NUM_7:number = 55;
+	public static NUM_8:number = 56;
+	public static NUM_9:number = 57;
+	public static SUBSTRACT:number = 189;
+	public static ADD:number = 187;
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/LABColor.ts b/src/client/northstar/utils/LABColor.ts
new file mode 100644
index 000000000..72e46fb7f
--- /dev/null
+++ b/src/client/northstar/utils/LABColor.ts
@@ -0,0 +1,90 @@
+
+export class LABColor {
+    public L: number;
+    public A: number;
+    public B: number;
+
+    // constructor - takes three floats for lightness and color-opponent dimensions
+    constructor(l: number, a: number, b: number) {
+        this.L = l;
+        this.A = a;
+        this.B = b;
+    }
+
+    // static function for linear interpolation between two LABColors
+    public static Lerp(a: LABColor, b: LABColor, t: number): LABColor {
+        return new LABColor(LABColor.LerpNumber(a.L, b.L, t), LABColor.LerpNumber(a.A, b.A, t), LABColor.LerpNumber(a.B, b.B, t));
+    }
+
+    public static LerpNumber(a: number, b: number, percent: number): number {
+        return a + percent * (b - a);
+    }
+
+    static hexToRGB(hex: number, alpha: number): number[] {
+        var r = (hex & (0xff << 16)) >> 16;
+        var g = (hex & (0xff << 8)) >> 8;
+        var b = (hex & (0xff << 0)) >> 0;
+        return [r, g, b];
+    }
+    static RGBtoHex(red: number, green: number, blue: number): number {
+        return blue | (green << 8) | (red << 16);
+    }
+
+    public static RGBtoHexString(rgb: number): string {
+        let str = "#" + this.hex((rgb & (0xff << 16)) >> 16) + this.hex((rgb & (0xff << 8)) >> 8) + this.hex((rgb & (0xff << 0)) >> 0);
+        return str;
+    }
+
+    static hex(x: number): string {
+        var hexDigits = new Array
+            ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f");
+        return isNaN(x) ? "00" : hexDigits[(x - x % 16) / 16] + hexDigits[x % 16];
+    }
+
+    public static FromColor(c: number): LABColor {
+        var rgb = LABColor.hexToRGB(c, 0);
+        var r = LABColor.d3_rgb_xyz(rgb[0] * 255);
+        var g = LABColor.d3_rgb_xyz(rgb[1] * 255);
+        var b = LABColor.d3_rgb_xyz(rgb[2] * 255);
+
+        var x = LABColor.d3_xyz_lab((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / LABColor.d3_lab_X);
+        var y = LABColor.d3_xyz_lab((0.2126729 * r + 0.7151522 * g + 0.0721750 * b) / LABColor.d3_lab_Y);
+        var z = LABColor.d3_xyz_lab((0.0193339 * r + 0.1191920 * g + 0.9503041 * b) / LABColor.d3_lab_Z);
+        var lab = new LABColor(116 * y - 16, 500 * (x - y), 200 * (y - z));
+        return lab;
+    }
+
+    private static d3_lab_X: number = 0.950470;
+    private static d3_lab_Y: number = 1;
+    private static d3_lab_Z: number = 1.088830;
+
+    public static d3_lab_xyz(x: number): number {
+        return x > 0.206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
+    }
+
+    public static d3_xyz_rgb(r: number): number {
+        return Math.round(255 * (r <= 0.00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - 0.055));
+    }
+
+    public static d3_rgb_xyz(r: number): number {
+        return (r /= 255) <= 0.04045 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
+    }
+
+    public static d3_xyz_lab(x: number): number {
+        return x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+    }
+
+    public static ToColor(lab: LABColor): number {
+        var y = (lab.L + 16) / 116;
+        var x = y + lab.A / 500;
+        var z = y - lab.B / 200;
+        x = LABColor.d3_lab_xyz(x) * LABColor.d3_lab_X;
+        y = LABColor.d3_lab_xyz(y) * LABColor.d3_lab_Y;
+        z = LABColor.d3_lab_xyz(z) * LABColor.d3_lab_Z;
+
+        return LABColor.RGBtoHex(
+            LABColor.d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z) / 255,
+            LABColor.d3_xyz_rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z) / 255,
+            LABColor.d3_xyz_rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z) / 255);
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/MathUtil.ts b/src/client/northstar/utils/MathUtil.ts
new file mode 100644
index 000000000..bb7e73871
--- /dev/null
+++ b/src/client/northstar/utils/MathUtil.ts
@@ -0,0 +1,241 @@
+
+
+export class PIXIPoint {
+    public get x() { return this.coords[0]; }
+    public get y() { return this.coords[1]; }
+    public set x(value: number) { this.coords[0] = value; }
+    public set y(value: number) { this.coords[1] = value; }
+    public coords: number[] = [0, 0];
+    constructor(x: number, y: number) {
+        this.coords[0] = x;
+        this.coords[1] = y;
+    }
+}
+
+export class PIXIRectangle {
+    public x: number;
+    public y: number;
+    public width: number;
+    public height: number
+    public get left() { return this.x }
+    public get right() { return this.x + this.width; }
+    public get top() { return this.y }
+    public get bottom() { return this.top + this.height }
+    public static get EMPTY() { return new PIXIRectangle(0, 0, -1, -1); }
+    constructor(x: number, y: number, width: number, height: number) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+}
+
+export class MathUtil {
+
+    public static EPSILON: number = 0.001;
+
+    public static Sign(value: number): number {
+        return value >= 0 ? 1 : -1;
+    }
+
+    public static AddPoint(p1: PIXIPoint, p2: PIXIPoint, inline: boolean = false): PIXIPoint {
+        if (inline) {
+            p1.x += p2.x;
+            p1.y += p2.y;
+            return p1;
+        }
+        else {
+            return new PIXIPoint(p1.x + p2.x, p1.y + p2.y);
+        }
+    }
+
+    public static Perp(p1: PIXIPoint): PIXIPoint {
+        return new PIXIPoint(-p1.y, p1.x);
+    }
+
+    public static DividePoint(p1: PIXIPoint, by: number, inline: boolean = false): PIXIPoint {
+        if (inline) {
+            p1.x /= by;
+            p1.y /= by;
+            return p1;
+        }
+        else {
+            return new PIXIPoint(p1.x / by, p1.y / by);
+        }
+    }
+
+    public static MultiplyConstant(p1: PIXIPoint, by: number, inline: boolean = false) {
+        if (inline) {
+            p1.x *= by;
+            p1.y *= by;
+            return p1;
+        }
+        else {
+            return new PIXIPoint(p1.x * by, p1.y * by);
+        }
+    }
+
+    public static SubtractPoint(p1: PIXIPoint, p2: PIXIPoint, inline: boolean = false): PIXIPoint {
+        if (inline) {
+            p1.x -= p2.x;
+            p1.y -= p2.y;
+            return p1;
+        }
+        else {
+            return new PIXIPoint(p1.x - p2.x, p1.y - p2.y);
+        }
+    }
+
+    public static Area(rect: PIXIRectangle): number {
+        return rect.width * rect.height;
+    }
+
+    public static DistToLineSegment(v: PIXIPoint, w: PIXIPoint, p: PIXIPoint) {
+        // Return minimum distance between line segment vw and point p
+        var l2 = MathUtil.DistSquared(v, w);  // i.e. |w-v|^2 -  avoid a sqrt
+        if (l2 == 0.0) return MathUtil.Dist(p, v);   // v == w case
+        // Consider the line extending the segment, parameterized as v + t (w - v).
+        // We find projection of point p onto the line. 
+        // It falls where t = [(p-v) . (w-v)] / |w-v|^2
+        // We clamp t from [0,1] to handle points outside the segment vw.
+        var dot = MathUtil.Dot(
+            MathUtil.SubtractPoint(p, v),
+            MathUtil.SubtractPoint(w, v)) / l2;
+        var t = Math.max(0, Math.min(1, dot));
+        // Projection falls on the segment
+        var projection = MathUtil.AddPoint(v,
+            MathUtil.MultiplyConstant(
+                MathUtil.SubtractPoint(w, v), t));
+        return MathUtil.Dist(p, projection);
+    }
+
+    public static LineSegmentIntersection(ps1: PIXIPoint, pe1: PIXIPoint, ps2: PIXIPoint, pe2: PIXIPoint): PIXIPoint | undefined {
+        var a1 = pe1.y - ps1.y;
+        var b1 = ps1.x - pe1.x;
+
+        var a2 = pe2.y - ps2.y;
+        var b2 = ps2.x - pe2.x;
+
+        var delta = a1 * b2 - a2 * b1;
+        if (delta == 0) {
+            return undefined;
+        }
+        var c2 = a2 * ps2.x + b2 * ps2.y;
+        var c1 = a1 * ps1.x + b1 * ps1.y;
+        var invdelta = 1 / delta;
+        return new PIXIPoint((b2 * c1 - b1 * c2) * invdelta, (a1 * c2 - a2 * c1) * invdelta);
+    }
+
+    public static PointInPIXIRectangle(p: PIXIPoint, rect: PIXIRectangle): boolean {
+        if (p.x < rect.left - this.EPSILON)
+            return false;
+        if (p.x > rect.right + this.EPSILON)
+            return false;
+        if (p.y < rect.top - this.EPSILON)
+            return false;
+        if (p.y > rect.bottom + this.EPSILON)
+            return false;
+
+        return true;
+    }
+
+    public static LinePIXIRectangleIntersection(lineFrom: PIXIPoint, lineTo: PIXIPoint, rect: PIXIRectangle): Array<PIXIPoint> {
+        var r1 = new PIXIPoint(rect.left, rect.top);
+        var r2 = new PIXIPoint(rect.right, rect.top);
+        var r3 = new PIXIPoint(rect.right, rect.bottom);
+        var r4 = new PIXIPoint(rect.left, rect.bottom);
+        var ret = new Array<PIXIPoint>();
+        var dist = this.Dist(lineFrom, lineTo)
+        var inter = this.LineSegmentIntersection(lineFrom, lineTo, r1, r2);
+        if (inter != null && this.PointInPIXIRectangle(inter, rect) &&
+            this.Dist(inter, lineFrom) < dist && this.Dist(inter, lineTo) < dist)
+            ret.push(inter);
+        inter = this.LineSegmentIntersection(lineFrom, lineTo, r2, r3);
+        if (inter != null && this.PointInPIXIRectangle(inter, rect) &&
+            this.Dist(inter, lineFrom) < dist && this.Dist(inter, lineTo) < dist)
+            ret.push(inter);
+        inter = this.LineSegmentIntersection(lineFrom, lineTo, r3, r4);
+        if (inter != null && this.PointInPIXIRectangle(inter, rect) &&
+            this.Dist(inter, lineFrom) < dist && this.Dist(inter, lineTo) < dist)
+            ret.push(inter);
+        inter = this.LineSegmentIntersection(lineFrom, lineTo, r4, r1);
+        if (inter != null && this.PointInPIXIRectangle(inter, rect) &&
+            this.Dist(inter, lineFrom) < dist && this.Dist(inter, lineTo) < dist)
+            ret.push(inter);
+        return ret;
+    }
+
+    public static Intersection(rect1: PIXIRectangle, rect2: PIXIRectangle): PIXIRectangle {
+        const left = Math.max(rect1.x, rect2.x);
+        const right = Math.min(rect1.x + rect1.width, rect2.x + rect2.width);
+        const top = Math.max(rect1.y, rect2.y);
+        const bottom = Math.min(rect1.y + rect1.height, rect2.y + rect2.height);
+        return new PIXIRectangle(left, top, right - left, bottom - top);
+    }
+
+    public static Dist(p1: PIXIPoint, p2: PIXIPoint): number {
+        return Math.sqrt(MathUtil.DistSquared(p1, p2));
+    }
+
+    public static Dot(p1: PIXIPoint, p2: PIXIPoint): number {
+        return p1.x * p2.x + p1.y * p2.y
+    }
+
+    public static Normalize(p1: PIXIPoint) {
+        var d = this.Length(p1);
+        return new PIXIPoint(p1.x / d, p1.y / d);
+    }
+
+    public static Length(p1: PIXIPoint): number {
+        return Math.sqrt(p1.x * p1.x + p1.y * p1.y);
+    }
+
+    public static DistSquared(p1: PIXIPoint, p2: PIXIPoint): number {
+        const a = p1.x - p2.x;
+        const b = p1.y - p2.y;
+        return (a * a + b * b)
+    }
+
+    public static RectIntersectsRect(r1: PIXIRectangle, r2: PIXIRectangle): boolean {
+        return !(r2.x > r1.x + r1.width ||
+            r2.x + r2.width < r1.x ||
+            r2.y > r1.y + r1.height ||
+            r2.y + r2.height < r1.y);
+    }
+
+    public static ArgMin(temp: number[]): number {
+        let index = 0;
+        let value = temp[0];
+        for (let i = 1; i < temp.length; i++) {
+            if (temp[i] < value) {
+                value = temp[i];
+                index = i;
+            }
+        }
+        return index;
+    }
+
+    public static ArgMax(temp: number[]): number {
+        let index = 0;
+        let value = temp[0];
+        for (let i = 1; i < temp.length; i++) {
+            if (temp[i] > value) {
+                value = temp[i];
+                index = i;
+            }
+        }
+        return index;
+    }
+
+    public static Combinations<T>(chars: T[]) {
+        let result = new Array<T>();
+        let f = (prefix: any, chars: any) => {
+            for (let i = 0; i < chars.length; i++) {
+                result.push(prefix.concat(chars[i]));
+                f(prefix.concat(chars[i]), chars.slice(i + 1));
+            }
+        };
+        f([], chars);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/PartialClass.ts b/src/client/northstar/utils/PartialClass.ts
new file mode 100644
index 000000000..2f20de96f
--- /dev/null
+++ b/src/client/northstar/utils/PartialClass.ts
@@ -0,0 +1,7 @@
+
+export class PartialClass<T> {
+
+    constructor(data?: Partial<T>) {
+        Object.assign(this, data);
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/SizeConverter.ts b/src/client/northstar/utils/SizeConverter.ts
new file mode 100644
index 000000000..bb91ed4a7
--- /dev/null
+++ b/src/client/northstar/utils/SizeConverter.ts
@@ -0,0 +1,99 @@
+import { PIXIPoint } from "./MathUtil";
+import { VisualBinRange } from "../model/binRanges/VisualBinRange";
+import { Bin, DoubleValueAggregateResult, AggregateKey } from "../model/idea/idea";
+import { ModelHelpers } from "../model/ModelHelpers";
+import { observable, action, computed } from "mobx";
+
+export class SizeConverter {
+    public DataMins: Array<number> = new Array<number>(2);
+    public DataMaxs: Array<number> = new Array<number>(2);
+    public DataRanges: Array<number> = new Array<number>(2);
+    public MaxLabelSizes: Array<PIXIPoint> = new Array<PIXIPoint>(2);
+    public RenderDimension: number = 300;
+
+    @observable _leftOffset: number = 40;
+    @observable _rightOffset: number = 20;
+    @observable _topOffset: number = 20;
+    @observable _bottomOffset: number = 45;
+    @observable _labelAngle: number = 0;
+    @observable _isSmall: boolean = false;
+    @observable public Initialized = 0;
+
+    @action public SetIsSmall(isSmall: boolean) { this._isSmall = isSmall; }
+    @action public SetLabelAngle(angle: number) { this._labelAngle = angle; }
+    @computed public get IsSmall() { return this._isSmall; }
+    @computed public get LabelAngle() { return this._labelAngle; }
+    @computed public get LeftOffset() { return this.IsSmall ? 5 : this._leftOffset; }
+    @computed public get RightOffset() { return this.IsSmall ? 5 : !this._labelAngle ? this._bottomOffset : Math.max(this._rightOffset, Math.cos(this._labelAngle) * (this.MaxLabelSizes[0].x + 18)); }
+    @computed public get TopOffset() { return this.IsSmall ? 5 : this._topOffset; }
+    @computed public get BottomOffset() { return this.IsSmall ? 25 : !this._labelAngle ? this._bottomOffset : Math.max(this._bottomOffset, Math.sin(this._labelAngle) * (this.MaxLabelSizes[0].x + 18)) + 18; }
+
+    public SetVisualBinRanges(visualBinRanges: Array<VisualBinRange>) {
+        this.Initialized++;
+        var xLabels = visualBinRanges[0].GetLabels();
+        var yLabels = visualBinRanges[1].GetLabels();
+        var xLabelStrings = xLabels.map(l => l.label!).sort(function (a, b) { return b.length - a.length });
+        var yLabelStrings = yLabels.map(l => l.label!).sort(function (a, b) { return b.length - a.length });
+
+        var metricsX = { width: 75 }; // RenderUtils.MeasureText(FontStyles.Default.fontFamily.toString(), 12, // FontStyles.AxisLabel.fontSize as number,
+        //xLabelStrings[0]!.slice(0, 20)) // StyleConstants.MAX_CHAR_FOR_HISTOGRAM_LABELS));
+        var metricsY = { width: 22 }; // RenderUtils.MeasureText(FontStyles.Default.fontFamily.toString(), 12, // FontStyles.AxisLabel.fontSize as number,
+        // yLabelStrings[0]!.slice(0, 20)); // StyleConstants.MAX_CHAR_FOR_HISTOGRAM_LABELS));
+        this.MaxLabelSizes[0] = new PIXIPoint(metricsX.width, 12);// FontStyles.AxisLabel.fontSize as number);
+        this.MaxLabelSizes[1] = new PIXIPoint(metricsY.width, 12); // FontStyles.AxisLabel.fontSize as number);
+
+        this._leftOffset = Math.max(10, metricsY.width + 10 + 20);
+
+        this.DataMins[0] = xLabels.map(l => l.minValue!).reduce((m, c) => Math.min(m, c), Number.MAX_VALUE);
+        this.DataMins[1] = yLabels.map(l => l.minValue!).reduce((m, c) => Math.min(m, c), Number.MAX_VALUE);
+        this.DataMaxs[0] = xLabels.map(l => l.maxValue!).reduce((m, c) => Math.max(m, c), Number.MIN_VALUE);
+        this.DataMaxs[1] = yLabels.map(l => l.maxValue!).reduce((m, c) => Math.max(m, c), Number.MIN_VALUE);
+
+        this.DataRanges[0] = this.DataMaxs[0] - this.DataMins[0];
+        this.DataRanges[1] = this.DataMaxs[1] - this.DataMins[1];
+    }
+
+    public DataToScreenNormalizedRange(dataValue: number, normalization: number, axis: number, binBrushMaxAxis: number) {
+        var value = normalization != 1 - axis || binBrushMaxAxis == 0 ? dataValue : (dataValue - 0) / (binBrushMaxAxis - 0) * this.DataRanges[axis];
+        var from = this.DataToScreenCoord(Math.min(0, value), axis);
+        var to = this.DataToScreenCoord(Math.max(0, value), axis);
+        return [from, value, to];
+    }
+
+    public DataToScreenPointRange(axis: number, bin: Bin, aggregateKey: AggregateKey) {
+        var value = ModelHelpers.GetAggregateResult(bin, aggregateKey) as DoubleValueAggregateResult;
+        if (value && value.hasResult)
+            return [this.DataToScreenCoord(value.result!, axis) - 5,
+            this.DataToScreenCoord(value.result!, axis) + 5];
+        return [undefined, undefined];
+    }
+
+    public DataToScreenXAxisRange(visualBinRanges: VisualBinRange[], index: number, bin: Bin) {
+        var value = visualBinRanges[0].GetValueFromIndex(bin.binIndex!.indices![index]);
+        return [this.DataToScreenX(value), this.DataToScreenX(visualBinRanges[index].AddStep(value))]
+    }
+    public DataToScreenYAxisRange(visualBinRanges: VisualBinRange[], index: number, bin: Bin) {
+        var value = visualBinRanges[1].GetValueFromIndex(bin.binIndex!.indices![index]);
+        return [this.DataToScreenY(value), this.DataToScreenY(visualBinRanges[index].AddStep(value))]
+    }
+
+    public DataToScreenX(x: number): number {
+        return ((x - this.DataMins[0]) / this.DataRanges[0]) * this.RenderDimension;
+    }
+    public DataToScreenY(y: number, flip: boolean = true) {
+        var retY = ((y - this.DataMins[1]) / this.DataRanges[1]) * this.RenderDimension;
+        return flip ? (this.RenderDimension) - retY : retY;
+    }
+    public DataToScreenCoord(v: number, axis: number) {
+        if (axis == 0)
+            return this.DataToScreenX(v);
+        return this.DataToScreenY(v);
+    }
+    public DataToScreenRange(minVal: number, maxVal: number, axis: number) {
+        let xFrom = this.DataToScreenX(axis === 0 ? minVal : this.DataMins[0]);
+        let xTo = this.DataToScreenX(axis === 0 ? maxVal : this.DataMaxs[0]);
+        let yFrom = this.DataToScreenY(axis === 1 ? minVal : this.DataMins[1]);
+        let yTo = this.DataToScreenY(axis === 1 ? maxVal : this.DataMaxs[1]);
+        return { xFrom, yFrom, xTo, yTo }
+    }
+}
\ No newline at end of file
diff --git a/src/client/northstar/utils/StyleContants.ts b/src/client/northstar/utils/StyleContants.ts
new file mode 100644
index 000000000..ac8617e3b
--- /dev/null
+++ b/src/client/northstar/utils/StyleContants.ts
@@ -0,0 +1,95 @@
+import { PIXIPoint } from "./MathUtil";
+
+export class StyleConstants {
+
+    static DEFAULT_FONT: string = "Roboto Condensed";
+
+    static MENU_SUBMENU_WIDTH: number = 85;
+    static MENU_SUBMENU_HEIGHT: number = 400;
+    static MENU_BOX_SIZE: PIXIPoint = new PIXIPoint(80, 35);
+    static MENU_BOX_PADDING: number = 10;
+
+    static OPERATOR_MENU_LARGE: number = 35;
+    static OPERATOR_MENU_SMALL: number = 25;
+    static BRUSH_PALETTE: number[] = [0x42b43c, 0xfa217f, 0x6a9c75, 0xfb5de7, 0x25b8ea, 0x9b5bc4, 0xda9f63, 0xe23209, 0xfb899b, 0x94a6fd]
+    static GAP: number = 3;
+
+    static BACKGROUND_COLOR: number = 0xF3F3F3;
+    static TOOL_TIP_BACKGROUND_COLOR: number = 0xffffff;
+    static LIGHT_TEXT_COLOR: number = 0xffffff;
+    static LIGHT_TEXT_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.LIGHT_TEXT_COLOR);
+    static DARK_TEXT_COLOR: number = 0x282828;
+    static HIGHLIGHT_TEXT_COLOR: number = 0xffcc00;
+    static FPS_TEXT_COLOR: number = StyleConstants.DARK_TEXT_COLOR;
+    static CORRELATION_LABEL_TEXT_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.DARK_TEXT_COLOR);
+    static LOADING_SCREEN_TEXT_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.DARK_TEXT_COLOR);
+    static ERROR_COLOR: number = 0x540E25;
+    static WARNING_COLOR: number = 0xE58F24;
+    static LOWER_THAN_NAIVE_COLOR: number = 0xee0000;
+    static HIGHLIGHT_COLOR: number = 0x82A8D9;
+    static HIGHLIGHT_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.HIGHLIGHT_COLOR);
+    static OPERATOR_BACKGROUND_COLOR: number = 0x282828;
+    static LOADING_ANIMATION_COLOR: number = StyleConstants.OPERATOR_BACKGROUND_COLOR;
+    static MENU_COLOR: number = 0x282828;
+    static MENU_FONT_COLOR: number = StyleConstants.LIGHT_TEXT_COLOR;
+    static MENU_SELECTED_COLOR: number = StyleConstants.HIGHLIGHT_COLOR;
+    static MENU_SELECTED_FONT_COLOR: number = StyleConstants.LIGHT_TEXT_COLOR;
+    static BRUSH_COLOR: number = 0xff0000;
+    static DROP_ACCEPT_COLOR: number = StyleConstants.HIGHLIGHT_COLOR;
+    static SELECTED_COLOR: number = 0xffffff;
+    static SELECTED_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.SELECTED_COLOR);
+    static PROGRESS_BACKGROUND_COLOR: number = 0x595959;
+    static GRID_LINES_COLOR: number = 0x3D3D3D;
+    static GRID_LINES_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.GRID_LINES_COLOR);
+
+    static MAX_CHAR_FOR_HISTOGRAM_LABELS: number = 20;
+
+    static OVERLAP_COLOR: number = 0x0000ff;//0x540E25;
+    static BRUSH_COLORS: Array<number> = new Array<number>(
+        0xFFDA7E, 0xFE8F65, 0xDA5655, 0x8F2240
+    );
+
+    static MIN_VALUE_COLOR: number = 0x373d43; //32343d, 373d43,  3b4648
+    static MARGIN_BARS_COLOR: number = 0xffffff;
+    static MARGIN_BARS_COLOR_STR: string = StyleConstants.HexToHexString(StyleConstants.MARGIN_BARS_COLOR);
+
+    static HISTOGRAM_WIDTH: number = 200;
+    static HISTOGRAM_HEIGHT: number = 150;
+    static PREDICTOR_WIDTH: number = 150;
+    static PREDICTOR_HEIGHT: number = 100;
+    static RAWDATA_WIDTH: number = 150;
+    static RAWDATA_HEIGHT: number = 100;
+    static FREQUENT_ITEM_WIDTH: number = 180;
+    static FREQUENT_ITEM_HEIGHT: number = 100;
+    static CORRELATION_WIDTH: number = 555;
+    static CORRELATION_HEIGHT: number = 390;
+    static PROBLEM_FINDER_WIDTH: number = 450;
+    static PROBLEM_FINDER_HEIGHT: number = 150;
+    static PIPELINE_OPERATOR_WIDTH: number = 300;
+    static PIPELINE_OPERATOR_HEIGHT: number = 120;
+    static SLICE_WIDTH: number = 150;
+    static SLICE_HEIGHT: number = 45;
+    static BORDER_MENU_ITEM_WIDTH: number = 50;
+    static BORDER_MENU_ITEM_HEIGHT: number = 30;
+
+
+    static SLICE_BG_COLOR: string = StyleConstants.HexToHexString(StyleConstants.OPERATOR_BACKGROUND_COLOR);
+    static SLICE_EMPTY_COLOR: number = StyleConstants.OPERATOR_BACKGROUND_COLOR;
+    static SLICE_OCCUPIED_COLOR: number = 0xffffff;
+    static SLICE_OCCUPIED_BG_COLOR: string = StyleConstants.HexToHexString(StyleConstants.OPERATOR_BACKGROUND_COLOR);
+    static SLICE_HOVER_BG_COLOR: string = StyleConstants.HexToHexString(StyleConstants.HIGHLIGHT_COLOR);
+    static SLICE_HOVER_COLOR: number = 0xffffff;
+
+    static HexToHexString(hex: number): string {
+        if (hex === undefined) {
+            return "#000000";
+        }
+        var s = hex.toString(16);
+        while (s.length < 6) {
+            s = "0" + s;
+        }
+        return "#" + s;
+    }
+
+
+} 
diff --git a/src/client/northstar/utils/Utils.ts b/src/client/northstar/utils/Utils.ts
new file mode 100644
index 000000000..b35dce820
--- /dev/null
+++ b/src/client/northstar/utils/Utils.ts
@@ -0,0 +1,75 @@
+import { IBaseBrushable } from '../core/brusher/IBaseBrushable'
+import { IBaseFilterConsumer } from '../core/filter/IBaseFilterConsumer'
+import { IBaseFilterProvider } from '../core/filter/IBaseFilterProvider'
+import { AggregateFunction } from '../model/idea/idea'
+
+export class Utils {
+
+    public static EqualityHelper(a: Object, b: Object): boolean {
+        if (a === b) return true;
+        if (a === undefined && b !== undefined) return false;
+        if (a === null && b !== null) return false;
+        if (b === undefined && a !== undefined) return false;
+        if (b === null && a !== null) return false;
+        if ((<any>a).constructor.name !== (<any>b).constructor.name) return false;
+        return true;
+    }
+
+    public static LowercaseFirstLetter(str: string) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+
+    //
+    // this Type Guard tests if dropTarget is an IDropTarget.  If it is, it coerces the compiler
+    // to treat the dropTarget parameter as an IDropTarget *ouside* this function scope (ie, in
+    // the scope of where this function is called from).
+    //
+
+    public static isBaseBrushable<T>(obj: Object): obj is IBaseBrushable<T> {
+        let typed = <IBaseBrushable<T>>obj;
+        return typed != null && typed.BrusherModels !== undefined;
+    }
+
+    public static isBaseFilterProvider(obj: Object): obj is IBaseFilterProvider {
+        let typed = <IBaseFilterProvider>obj;
+        return typed != null && typed.FilterModels !== undefined;
+    }
+
+    public static isBaseFilterConsumer(obj: Object): obj is IBaseFilterConsumer {
+        let typed = <IBaseFilterConsumer>obj;
+        return typed != null && typed.FilterOperand !== undefined;
+    }
+
+    public static EncodeQueryData(data: any): string {
+        const ret = [];
+        for (let d in data) {
+            ret.push(encodeURIComponent(d) + "=" + encodeURIComponent(data[d]));
+        }
+        return ret.join("&");
+    }
+
+    public static ToVegaAggregationString(agg: AggregateFunction): string {
+        if (agg === AggregateFunction.Avg) {
+            return "average";
+        }
+        else if (agg === AggregateFunction.Count) {
+            return "count";
+        }
+        else {
+            return "";
+        }
+    }
+
+    public static GetQueryVariable(variable: string) {
+        let query = window.location.search.substring(1);
+        let vars = query.split("&");
+        for (let i = 0; i < vars.length; i++) {
+            let pair = vars[i].split("=");
+            if (decodeURIComponent(pair[0]) == variable) {
+                return decodeURIComponent(pair[1]);
+            }
+        }
+        return undefined;
+    }
+}
+