--- a/Resources/CodeGeneration/template.in.ts	Mon Feb 18 15:38:05 2019 +0100
+++ b/Resources/CodeGeneration/template.in.ts	Wed Feb 20 20:51:30 2019 +0100
@@ -1,38 +1,125 @@
-class Greeter {
-    greeting: string;
-    constructor(message: string) {
-        this.greeting = message;
+/*
+         1         2         3         4         5         6         7
+12345678901234567890123456789012345678901234567890123456789012345678901234567890
+*/
+
+namespace {{rootName}}
+{
+  function StoneCheckSerializedValueType(value: any, typeStr: string)
+  {
+    StoneCheckSerializedValueTypeGeneric(value);
+
+    if (value['type'] != typeStr)
+    {
+      throw new Error(
+        `Cannot deserialize type ${value['type']} into ${typeStr}`);
     }
-    greet() {
-        return "Hello, " + this.greeting;
+  }
+
+  function isString(val: any) :boolean
+  {
+    return ((typeof val === 'string') || (val instanceof String));
+  }
+  
+  function StoneCheckSerializedValueTypeGeneric(value: any)
+  {
+    if ( (!('type' in value)) || (!isString(value)) )
+    {
+      throw new Error(
+        "Cannot deserialize value ('type' key invalid)");
     }
-}
-enum Color { Red, Green, Blue };
+  }
+
+// end of generic methods
+{% for enum in enums%}
+  export enum {{enum['name']}} {
+    {% for key in enumDict.keys()%}
+    {{key}},
+    {%endfor%}
+  };
+{%endfor%}
+
+  export class Message1 {
+    a: number;
+    b: string;
+    c: EnumMonth0;
+    d: boolean;
+    public StoneSerialize(): string {
+      let container: object = {};
+      container['type'] = 'VsolStuff.Message1';
+      container['value'] = this;
+      return JSON.stringify(container);
+    }
+  };
 
-class TestMessage {
-    s1: string;
-    s2: Array<string>;
-    s3: Array<Array<string>>;
-    s4: Map<string, number>;
-    s5: Map<number, Array<string>>;
-    s6: Color;
-    s7: boolean;
-}
+  export class Message2 {
+    constructor()
+    {
+      this.tata = new Array<Message1>();
+      this.tutu = new Array<string>();
+      this.titi = new Map<string, string>();
+      this.lulu = new Map<string, Message1>();  
+    }
+    toto: string;
+    tata: Message1[];
+    tutu: string[];
+    titi: Map<string, string>;
+    lulu: Map<string, Message1>;
+
+    public StoneSerialize(): string {
+      let container: object = {};
+      container['type'] = 'VsolStuff.Message2';
+      container['value'] = this;
+      return JSON.stringify(container);
+    }
+    public static StoneDeserialize(valueStr: string) : Message2
+    {
+      let value: any = JSON.parse(valueStr);
+      StoneCheckSerializedValueType(value, "VsolStuff.Message2");
+      let result: Message2 = value['value'] as Message2;
+      return result;
+    }
+    };
+
+  export interface IDispatcher
+  {
+    HandleMessage1(value: Message1): boolean;
+    HandleMessage2(value: Message2): boolean;
+  };
 
-let tm = new TestMessage();
-tm.s2 = new Array<string>()
-tm.s2.push("toto");
-tm.s2.push("toto2");
-tm.s2.push("toto3");
-tm.s4 = new Map<string, number>();
-tm.s4["toto"] = 42;
-tm.s4["toto"] = 1999;
-tm.s4["tatata"] = 1999;
-tm.s6 = Color.Red;
-tm.s7 = true
+  /** Service function for StoneDispatchToHandler */
+  export function StoneDispatchJsonToHandler(
+    jsonValueStr: string, dispatcher: IDispatcher): boolean
+  {
+    let jsonValue: any = JSON.parse(jsonValueStr);
+    StoneCheckSerializedValueTypeGeneric(jsonValue);
+    let type: string = jsonValue["type"];
+    if (type == "")
+    {
+      // this should never ever happen
+      throw new Error("Caught empty type while dispatching");
+    }
+    else if (type == "VsolStuff.Message1")
+    {
+      let value = jsonValue["value"] as Message1;
+      return dispatcher.HandleMessage1(value);
+    }
+    else if (type == "VsolStuff.Message2")
+    {
+      let value = jsonValue["value"] as Message2;
+      return dispatcher.HandleMessage2(value);
+    }
+    else
+    {
+      return false;
+    }
+  }
 
-let txt = JSON.stringify(tm)
-console.log(txt);
-
-let greeter = new Greeter("world");
-
+  /** Takes a serialized type and passes this to the dispatcher */
+  export function StoneDispatchToHandler(
+    strValue: string, dispatcher: IDispatcher): boolean
+  {
+    let jsonValue: any = JSON.parse(strValue)
+    return StoneDispatchJsonToHandler(jsonValue, dispatcher);
+  }
+}