started to integrate Northstar. changed server port to 4321.

10 files changed, 8896 insertions, 10 deletions

diff --git a/deploy/assets/env.json b/deploy/assets/env.json
new file mode 100644
index 000000000..80963ea0d
--- /dev/null
+++ b/deploy/assets/env.json
@@ -0,0 +1,15 @@
+{
+    "IS_DARPA": false,
+    "IS_IGT": false,
+    "IS_MENU_FIXED": true,
+    "SERVER_URL": "http://localhost:1234",
+    "SERVER_API_PATH": "api",
+    "SAMPLE_SIZE": 100000,
+    "X_BINS": 15,
+    "Y_BINS": 15,
+    "SPLASH_TIME_IN_MS": 0,
+    "SHOW_FPS_COUNTER": true,
+    "SHOW_SHUTDOWN_BUTTON": false,
+    "DEGREE_OF_PARALLISM": 1,
+    "SHOW_WARNINGS": false
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 7ed94c508..c87e31bc4 100644
--- a/package.json
+++ b/package.json
@@ -38,9 +38,9 @@
     "@fortawesome/free-solid-svg-icons": "^5.7.2",
     "@fortawesome/react-fontawesome": "^0.1.4",
     "@hig/flyout": "^1.0.3",
-    "@types/async": "^2.4.1",
     "@hig/theme-context": "^2.1.3",
     "@hig/theme-data": "^2.3.3",
+    "@types/async": "^2.4.1",
     "@types/bcrypt-nodejs": "0.0.30",
     "@types/bluebird": "^3.5.25",
     "@types/body-parser": "^1.17.0",
@@ -149,6 +149,7 @@
     "socket.io": "^2.2.0",
     "socket.io-client": "^2.2.0",
     "socketio": "^1.0.0",
+    "typescript-collections": "^1.3.2",
     "url-loader": "^1.1.2",
     "uuid": "^3.3.2",
     "xoauth2": "^1.2.0"
diff --git a/src/client/Server.ts b/src/client/Server.ts
index 3fb1ae878..bbdc27397 100644
--- a/src/client/Server.ts
+++ b/src/client/Server.ts
@@ -9,7 +9,7 @@ import { MessageStore, Types } from "./../server/Message";
 
 export class Server {
     public static ClientFieldsCached: ObservableMap<FieldId, Field | FIELD_WAITING> = new ObservableMap();
-    static Socket: SocketIOClient.Socket = OpenSocket(`${window.location.protocol}//${window.location.hostname}:1234`);
+    static Socket: SocketIOClient.Socket = OpenSocket(`${window.location.protocol}//${window.location.hostname}:4321`);
     static GUID: string = Utils.GenerateGuid()
 
 
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/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/views/Main.tsx b/src/client/views/Main.tsx
index 8a52a501c..ac51a7d87 100644
--- a/src/client/views/Main.tsx
+++ b/src/client/views/Main.tsx
@@ -43,6 +43,8 @@ import { CurrentUserUtils } from '../../server/authentication/models/current_use
 import { Field, Opt } from '../../fields/Field';
 import { ListField } from '../../fields/ListField';
 import { map } from 'bluebird';
+import { Gateway, Settings } from '../northstar/manager/Gateway';
+import { Catalog } from '../northstar/model/idea/idea';
 
 @observer
 export class Main extends React.Component {
@@ -52,6 +54,7 @@ export class Main extends React.Component {
     @observable private userWorkspaces: Document[] = [];
     @observable public pwidth: number = 0;
     @observable public pheight: number = 0;
+    @observable private _northstarCatalog: Catalog | undefined = undefined;
 
     public mainDocId: string | undefined;
     private currentUser?: DashUserModel;
@@ -65,7 +68,9 @@ export class Main extends React.Component {
         if (window.location.pathname !== RouteStore.home) {
             let pathname = window.location.pathname.split("/");
             this.mainDocId = pathname[pathname.length - 1];
-        }
+        };
+
+        this.initializeNorthstar();
 
         CurrentUserUtils.loadCurrentUser();
 
@@ -82,9 +87,26 @@ export class Main extends React.Component {
         library.add(faMusic);
 
         this.initEventListeners();
-        Documents.initProtos(() => {
-            this.initAuthenticationRouters();
+        Documents.initProtos(() => this.initAuthenticationRouters());
+    }
+
+    @action SetNorthstarCatalog(ctlog: Catalog) {
+        this._northstarCatalog = ctlog;
+        if (this._northstarCatalog) {
+            console.log("CATALOG " + this._northstarCatalog.schemas);
+        }
+    }
+    async initializeNorthstar(): Promise<void> {
+        let envPath = "assets/env.json";
+        const response = await fetch(envPath, {
+            redirect: "follow",
+            method: "GET",
+            credentials: "include"
         });
+        const env = await response.json();
+        Settings.Instance.Update(env);
+        let cat = Gateway.Instance.ClearCatalog();
+        cat.then(async () => this.SetNorthstarCatalog(await Gateway.Instance.GetCatalog()));
     }
 
     onHistory = () => {
diff --git a/src/client/views/collections/CollectionSchemaView.tsx b/src/client/views/collections/CollectionSchemaView.tsx
index 50f5e9618..062babe58 100644
--- a/src/client/views/collections/CollectionSchemaView.tsx
+++ b/src/client/views/collections/CollectionSchemaView.tsx
@@ -9,7 +9,6 @@ import { Field, Opt } from "../../../fields/Field";
 import { KeyStore } from "../../../fields/KeyStore";
 import { CompileScript, ToField } from "../../util/Scripting";
 import { Transform } from "../../util/Transform";
-import { ContextMenu } from "../ContextMenu";
 import { EditableView } from "../EditableView";
 import { DocumentView } from "../nodes/DocumentView";
 import { FieldView, FieldViewProps } from "../nodes/FieldView";
@@ -27,8 +26,7 @@ import { ListField } from "../../../fields/ListField";
 
 @observer
 class KeyToggle extends React.Component<{ keyId: string, checked: boolean, toggle: (key: Key) => void }> {
-    @observable
-    key: Key | undefined;
+    @observable key: Key | undefined;
 
     componentWillReceiveProps() {
         Server.GetField(this.props.keyId, action((field: Opt<Field>) => {
diff --git a/src/server/index.ts b/src/server/index.ts
index 6226dbfe2..d1eb6847d 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -18,7 +18,7 @@ import { getLogin, postLogin, getSignup, postSignup, getLogout, postReset, getFo
 const config = require('../../webpack.config');
 const compiler = webpack(config);
 const port = 1050; // default port to listen
-const serverPort = 1234;
+const serverPort = 4321;
 import * as expressValidator from 'express-validator';
 import expressFlash = require('express-flash');
 import flash = require('connect-flash');
diff --git a/webpack.config.js b/webpack.config.js
index ff03181c9..5ba9dd4b5 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -77,7 +77,7 @@ module.exports = {
     compress: false,
     host: "localhost",
     contentBase: path.join(__dirname, 'deploy'),
-    port: 1234,
+    port: 4321,
     hot: true,
     https: false,
     overlay: {