diff --git a/compiler/cpp/src/generate/t_js_generator.cc b/compiler/cpp/src/generate/t_js_generator.cc
index be0c331..7787dfb 100644
--- a/compiler/cpp/src/generate/t_js_generator.cc
+++ b/compiler/cpp/src/generate/t_js_generator.cc
@@ -60,9 +60,14 @@
      iter = parsed_options.find("jquery");
      gen_jquery_ = (iter != parsed_options.end());
 
-	 if (gen_node_ && gen_jquery_) {
+     if (!gen_node_) {
+       iter = parsed_options.find("ts");
+       gen_ts_ = (iter != parsed_options.end());
+     }
+     
+     if (gen_node_ && gen_jquery_) {
        throw "Invalid switch: [-gen js:node,jquery] options not compatible, try: [-gen js:node -gen js:jquery]";
-	 }
+     }
 
      if (gen_node_) {
        out_dir_base_ = "gen-nodejs";
@@ -235,6 +240,60 @@
       return ns;
   }
 
+  /**
+   * TypeScript Definition File helper functions
+   */
+
+  string ts_function_signature(t_function* tfunction, bool include_callback);
+  string ts_get_type(t_type* type);
+
+  /**
+   * Special indentation for TypeScript Definitions because of the module.
+   * Returns the normal indentation + "  " if a module was defined.
+   * @return string
+   */
+  string ts_indent() {
+    return indent() + (!ts_module_.empty() ? "  " : "");
+  }
+
+  /**
+   * Returns "declare " if no module was defined.
+   * @return string
+   */
+  string ts_declare() {
+    return (ts_module_.empty() ? "declare " : "");
+  }
+
+  /**
+   * Returns "?" if the given field is optional.
+   * @param t_field The field to check
+   * @return string
+   */
+  string ts_get_req(t_field* field) {
+    return (field->get_req() == t_field::T_OPTIONAL ? "?" : "");
+  }
+
+  /**
+   * Returns the documentation, if the provided documentable object has one.
+   * @param t_doc The object to get the documentation from
+   * @return string The documentation
+   */
+  string ts_print_doc(t_doc* tdoc) {
+    string result = endl;
+
+    if (tdoc->has_doc()) {
+      std::stringstream doc(tdoc->get_doc());
+      string item;
+      
+      result += ts_indent() + "/**" + endl;
+      while (std::getline(doc, item)) {
+        result += ts_indent() + " * " + item + endl;
+      }
+      result += ts_indent() + " */" + endl;
+    }
+    return result;
+  }
+
  private:
 
   /**
@@ -248,10 +307,22 @@
   bool gen_jquery_;
 
   /**
+   * True if we should generate a TypeScript Definition File for each service.
+   */
+  bool gen_ts_;
+
+  /**
+   * The name of the defined module(s), for TypeScript Definition Files.
+   */
+  string ts_module_;
+
+  /**
    * File streams
    */
   std::ofstream f_types_;
   std::ofstream f_service_;
+  std::ofstream f_types_ts_;
+  std::ofstream f_service_ts_;
 };
 
 
@@ -267,16 +338,25 @@
 
   string outdir = get_out_dir();
 
-  // Make output file
+  // Make output file(s)
   string f_types_name = outdir+program_->get_name()+"_types.js";
   f_types_.open(f_types_name.c_str());
 
+  if (gen_ts_) {
+    string f_types_ts_name = outdir + program_->get_name() + "_types.d.ts";
+    f_types_ts_.open(f_types_ts_name.c_str());
+  }
+
   // Print header
   f_types_ <<
     autogen_comment() <<
     js_includes() << endl <<
     render_includes() << endl;
 
+  if (gen_ts_) {
+    f_types_ts_ << autogen_comment() << endl;
+  }
+
   if (gen_node_) {
     f_types_ << "var ttypes = module.exports = {};" << endl;
   }
@@ -293,6 +373,10 @@
         f_types_ << "  " << pns << " = {};" << endl;
         f_types_ << "}" << endl;
     }
+    if (gen_ts_) {
+      ts_module_ = pns;
+      f_types_ts_ << "declare module " << ts_module_ << " {";
+    }
   }
 
 }
@@ -333,9 +417,16 @@
  * Close up (or down) some filez.
  */
 void t_js_generator::close_generator() {
-  // Close types file
+  // Close types file(s)
 
   f_types_.close();
+
+  if (gen_ts_) {
+    if (!ts_module_.empty()) {
+      f_types_ts_ << "}";
+    }
+    f_types_ts_.close();
+  }
 }
 
 /**
@@ -356,18 +447,37 @@
 void t_js_generator::generate_enum(t_enum* tenum) {
   f_types_ << js_type_namespace(tenum->get_program())<<tenum->get_name()<<" = {"<<endl;
 
+  if (gen_ts_) {
+    f_types_ts_ <<
+      ts_print_doc(tenum) <<
+      ts_indent() << ts_declare() << "enum " << tenum->get_name() << " {" << endl;
+  }
+
+  indent_up();
+
   vector<t_enum_value*> constants = tenum->get_constants();
   vector<t_enum_value*>::iterator c_iter;
   for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
     int value = (*c_iter)->get_value();
-    f_types_ << "'" << (*c_iter)->get_name() << "' : " << value;
+    if (gen_ts_) {
+      f_types_ts_ << ts_indent() << "'" << (*c_iter)->get_name() << "' = " << value << "," << endl;
+      //add 'value: key' in addition to 'key: value' for TypeScript enums
+      f_types_ << indent() << "'" << value << "' : '" << (*c_iter)->get_name() << "'," << endl;
+    }
+    f_types_ << indent() << "'" << (*c_iter)->get_name() << "' : " << value;
     if (c_iter != constants.end()-1) {
         f_types_ << ",";
     }
     f_types_ << endl;
   }
 
+  indent_down();
+
   f_types_ << "};"<<endl;
+
+  if (gen_ts_) {
+    f_types_ts_ << ts_indent() << "}" << endl;
+  }
 }
 
 /**
@@ -380,6 +490,12 @@
 
   f_types_ << js_type_namespace(program_)  << name << " = ";
   f_types_ << render_const_value(type, value) << ";" << endl;
+
+  if (gen_ts_) {
+    f_types_ts_ <<
+      ts_print_doc(tconst) <<
+      ts_indent() << ts_declare() << "var " << name << ": " << ts_get_type(type) << ";" << endl;
+  }
 }
 
 /**
@@ -522,19 +638,24 @@
   const vector<t_field*>& members = tstruct->get_members();
   vector<t_field*>::const_iterator m_iter;
 
-  indent_up();
-
   if (gen_node_) {
     if (is_exported) {
       out << js_namespace(tstruct->get_program()) << tstruct->get_name() << " = " <<
-        "module.exports." << tstruct->get_name() << " = function(args) {\n";
+        "module.exports." << tstruct->get_name() << " = function(args) {" << endl;
     } else {
-      out << js_namespace(tstruct->get_program()) << tstruct->get_name() << " = function(args) {\n";
+      out << js_namespace(tstruct->get_program()) << tstruct->get_name() << " = function(args) {" << endl;
     }
   } else {
-    out << js_namespace(tstruct->get_program()) << tstruct->get_name() <<" = function(args) {\n";
+    out << js_namespace(tstruct->get_program()) << tstruct->get_name() <<" = function(args) {" << endl;
+    if (gen_ts_) {
+      f_types_ts_ <<
+        ts_print_doc(tstruct) <<
+        ts_indent() << ts_declare() << "class " << tstruct->get_name() << (is_exception ? " extends Thrift.TException" : "" ) << " {" << endl;
+    }
   }
 
+  indent_up();
+
   if (gen_node_ && is_exception) {
       out << indent() << "Thrift.TException.call(this, \"" <<
           js_namespace(tstruct->get_program()) << tstruct->get_name() << "\")" << endl;
@@ -547,12 +668,14 @@
     string dval = declare_field(*m_iter,false,true);
     t_type* t = get_true_type((*m_iter)->get_type());
     if ((*m_iter)->get_value() != NULL && !(t->is_struct() || t->is_xception())) {
-        dval = render_const_value((*m_iter)-> get_type(), (*m_iter)->get_value());
+        dval = render_const_value((*m_iter)->get_type(), (*m_iter)->get_value());
         out << indent() << "this." << (*m_iter)->get_name() << " = " << dval << ";" << endl;
     } else {
         out << indent() <<  dval << ";" << endl;
     }
-
+    if (gen_ts_) {
+      f_types_ts_ << ts_indent() << (*m_iter)->get_name() << ": " << ts_get_type((*m_iter)->get_type()) << ";" << endl;
+    }
   }
 
   // Generate constructor from array
@@ -577,19 +700,31 @@
     }
 
     out << indent() <<  "if (args) {" << endl;
+    if (gen_ts_) {
+      f_types_ts_ << endl << ts_indent() << "constructor(args?: { ";
+    }
 
     for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
         out << indent() << indent() << "if (args." << (*m_iter)->get_name() << " !== undefined) {" << endl
             << indent() << indent() << indent() << "this." << (*m_iter)->get_name() << " = args." << (*m_iter)->get_name()  << ";" << endl
             << indent() << indent() << "}" << endl;
+        if (gen_ts_) {
+          f_types_ts_ << (*m_iter)->get_name() << ts_get_req(*m_iter) << ": " << ts_get_type((*m_iter)->get_type()) << "; ";
+        }
     }
 
     out << indent() <<  "}" << endl;
+    if (gen_ts_) {
+      f_types_ts_ << "});" << endl;
+    }
 
   }
 
   indent_down();
-  out << "};\n";
+  out << "};" << endl;
+  if (gen_ts_) {
+    f_types_ts_ << ts_indent() << "}" << endl;
+  }
 
   if (is_exception) {
     out << "Thrift.inherits(" <<
@@ -598,7 +733,7 @@
 	out << js_namespace(tstruct->get_program())<<tstruct->get_name() <<".prototype.name = '" << tstruct->get_name() << "';" << endl;
   } else {
     //init prototype
-    out << js_namespace(tstruct->get_program())<<tstruct->get_name() <<".prototype = {};\n";
+    out << js_namespace(tstruct->get_program())<<tstruct->get_name() <<".prototype = {};" << endl;
   }
 
 
@@ -749,11 +884,26 @@
     string f_service_name = get_out_dir()+service_name_+".js";
     f_service_.open(f_service_name.c_str());
 
+    if (gen_ts_) {
+      string f_service_ts_name = get_out_dir() + service_name_ + ".d.ts";
+      f_service_ts_.open(f_service_ts_name.c_str());
+    }
+
     f_service_ <<
       autogen_comment() <<
       js_includes() << endl <<
       render_includes() << endl;
 
+    if (gen_ts_) {
+      if (tservice->get_extends() != NULL) {
+        f_service_ts_ << "/// <reference path=\"" << tservice->get_extends()->get_name() << ".d.ts\" />" << endl;
+      }
+      f_service_ts_ << autogen_comment() << endl;
+      if (!ts_module_.empty()) {
+        f_service_ts_ << "declare module " << ts_module_ << " {";
+      }
+    }
+
     if (gen_node_) {
       if (tservice->get_extends() != NULL) {
         f_service_ <<
@@ -778,6 +928,12 @@
     }
 
     f_service_.close();
+    if (gen_ts_) {
+      if (!ts_module_.empty()) {
+        f_service_ts_ << "}";
+      }
+      f_service_ts_.close();
+    }
 }
 
 /**
@@ -946,6 +1102,10 @@
  * @param tservice The service to generate a header definition for
  */
 void t_js_generator::generate_service_helpers(t_service* tservice) {
+	  //Do not generate TS definitions for helper functions
+	  bool gen_ts_tmp = gen_ts_;
+	  gen_ts_ = false;
+
     vector<t_function*> functions = tservice->get_functions();
     vector<t_function*>::iterator f_iter;
 
@@ -960,6 +1120,8 @@
         generate_js_function_helpers(*f_iter);
         ts->set_name(name);
     }
+
+	  gen_ts_ = gen_ts_tmp;
 }
 
 /**
@@ -1006,8 +1168,6 @@
  * @param tservice The service to generate a server for.
  */
 void t_js_generator::generate_service_client(t_service* tservice) {
-  string extends = "";
-
   if (gen_node_) {
     f_service_ <<
         js_namespace(tservice->get_program()) << service_name_ << "Client = " <<
@@ -1015,6 +1175,15 @@
   } else {
     f_service_ <<
         js_namespace(tservice->get_program()) << service_name_ << "Client = function(input, output) {"<<endl;
+    if (gen_ts_) {
+      f_service_ts_ <<
+        ts_print_doc(tservice) <<
+        ts_indent() << ts_declare() << "class " << service_name_ << "Client ";
+      if (tservice->get_extends() != NULL) {
+        f_service_ts_ << "extends " << tservice->get_extends()->get_name() << "Client ";
+      }
+      f_service_ts_ << "{" << endl;
+    }
   }
 
   indent_up();
@@ -1031,6 +1200,14 @@
       indent() << "  this.input = input;" << endl <<
       indent() << "  this.output = (!output) ? input : output;" << endl <<
       indent() << "  this.seqid = 0;" << endl;
+    if (gen_ts_) {
+       f_service_ts_ <<
+         ts_indent() << "input: Thrift.TJSONProtocol;" << endl <<
+         ts_indent() << "output: Thrift.TJSONProtocol;" << endl <<
+         ts_indent() << "seqid: number;" << endl <<
+         endl <<
+         ts_indent() << "constructor(input: Thrift.TJSONProtocol, output?: Thrift.TJSONProtocol);" << endl;
+    }
   }
 
 
@@ -1044,7 +1221,7 @@
     indent(f_service_) << "Thrift.inherits(" <<
         js_namespace(tservice->get_program()) <<
         service_name_ << "Client, " <<
-        tservice->get_extends()->get_name() << "Client)" << endl;
+        tservice->get_extends()->get_name() << "Client);" << endl;
   } else {
       //init prototype
       indent(f_service_) <<  js_namespace(tservice->get_program())<<service_name_ << "Client.prototype = {};"<<endl;
@@ -1071,6 +1248,16 @@
 
     indent_up();
 
+    if (gen_ts_) {
+      f_service_ts_ <<
+      ts_print_doc(*f_iter) <<
+      //function definition without callback
+      ts_indent() << ts_function_signature(*f_iter, false) << endl <<
+      ts_print_doc(*f_iter) <<
+      //overload with callback
+      ts_indent() << ts_function_signature(*f_iter, true) << endl;
+    }
+
     if (gen_node_) {          //Node.js output      ./gen-nodejs
       f_service_ <<
         indent() << "this._seqid = this.new_seqid();" << endl <<
@@ -1303,6 +1490,10 @@
     }
   }
 
+  if (gen_ts_) {
+    f_service_ts_ << ts_indent() << "}" <<  endl;
+  }
+
 }
 
 std::string t_js_generator::render_recv_throw(std::string var) {
@@ -1858,7 +2049,7 @@
 /**
  * Converts the parse type to a C++ enum string for the given type.
  */
-string t_js_generator ::type_to_enum(t_type* type) {
+string t_js_generator::type_to_enum(t_type* type) {
   type = get_true_type(type);
 
   if (type->is_base_type()) {
@@ -1896,7 +2087,102 @@
   throw "INVALID TYPE IN type_to_enum: " + type->get_name();
 }
 
+/**
+ * Converts a t_type to a TypeScript type (string).
+ * @param t_type Type to convert to TypeScript
+ * @return String TypeScript type
+ */
+string t_js_generator::ts_get_type(t_type* type) {
+  std::string ts_type;
+
+  type = get_true_type(type);
+
+  if (type->is_base_type()) {
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
+    switch (tbase) {
+      case t_base_type::TYPE_STRING:
+        ts_type = "string";
+        break;
+      case t_base_type::TYPE_BOOL:
+        ts_type = "boolean";
+        break;
+      case t_base_type::TYPE_BYTE:
+        ts_type = "any";
+        break;
+      case t_base_type::TYPE_I16:
+      case t_base_type::TYPE_I32:
+      case t_base_type::TYPE_I64:
+      case t_base_type::TYPE_DOUBLE:
+        ts_type = "number";
+        break;
+      case t_base_type::TYPE_VOID:
+        ts_type = "void";
+    }
+  } else if (type->is_enum() || type->is_struct() || type->is_xception()) {
+    ts_type = type->get_name();
+  } else if (type->is_list() || type->is_set()) {
+    t_type* etype;
+
+    if (type->is_list()) {
+      etype = ((t_list*)type)->get_elem_type();
+    } else {
+      etype = ((t_set*)type)->get_elem_type();
+    }
+
+    ts_type = ts_get_type(etype) + "[]";
+  } else if (type->is_map()) {
+    string ktype = ts_get_type(((t_map*)type)->get_key_type());
+    string vtype = ts_get_type(((t_map*)type)->get_val_type());
+
+    if (ktype == "number" || ktype == "string") {
+      ts_type = "{ [k: " + ktype + "]: " + vtype + "; }";
+    } else {
+      ts_type = "any";
+    }
+  }
+
+  return ts_type;
+}
+
+/**
+ * Renders a TypeScript function signature of the form 'name(args: types): type;'
+ *
+ * @param t_function Function definition
+ * @param bool in-/exclude the callback argument
+ * @return String of rendered function definition
+ */
+std::string t_js_generator::ts_function_signature(t_function* tfunction, bool include_callback) {
+  string str;
+  const vector<t_field*>& fields = tfunction->get_arglist()->get_members();
+  vector<t_field*>::const_iterator f_iter;
+
+  str = tfunction->get_name() + "(";
+
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
+    str += (*f_iter)->get_name() + ts_get_req(*f_iter) + ": " + ts_get_type((*f_iter)->get_type());
+    
+    if (f_iter + 1 != fields.end()) {
+      str += ", ";
+    }
+  }
+
+  if (include_callback) {
+    str += ", callback: Function): ";
+
+    if (gen_jquery_) {
+      str += "JQueryXHR;";
+    } else {
+      str += "void;";
+    }
+  } else {
+    str += "): " + ts_get_type(tfunction->get_returntype()) + ";";
+  }
+
+  return str;
+}
+
 
 THRIFT_REGISTER_GENERATOR(js, "Javascript",
 "    jquery:          Generate jQuery compatible code.\n"
-"    node:            Generate node.js compatible code.\n")
+"    node:            Generate node.js compatible code.\n"
+"    ts:              Generate TypeScript Definition Files.\n")
diff --git a/lib/ts/thrift.d.ts b/lib/ts/thrift.d.ts
new file mode 100644
index 0000000..470adfe
--- /dev/null
+++ b/lib/ts/thrift.d.ts
@@ -0,0 +1,688 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+declare module Thrift {
+  /**
+   * Thrift JavaScript library version.
+   */
+  var Version: string;
+
+  /**
+   * Thrift IDL type string to Id mapping.
+   * @property {number}  STOP   - End of a set of fields.
+   * @property {number}  VOID   - No value (only legal for return types).
+   * @property {number}  BOOL   - True/False integer.
+   * @property {number}  BYTE   - Signed 8 bit integer.
+   * @property {number}  I08    - Signed 8 bit integer.     
+   * @property {number}  DOUBLE - 64 bit IEEE 854 floating point.
+   * @property {number}  I16    - Signed 16 bit integer.
+   * @property {number}  I32    - Signed 32 bit integer.
+   * @property {number}  I64    - Signed 64 bit integer.
+   * @property {number}  STRING - Array of bytes representing a string of characters.
+   * @property {number}  UTF7   - Array of bytes representing a string of UTF7 encoded characters.
+   * @property {number}  STRUCT - A multifield type.
+   * @property {number}  MAP    - A collection type (map/associative-array/dictionary).
+   * @property {number}  SET    - A collection type (unordered and without repeated values).
+   * @property {number}  LIST   - A collection type (unordered).
+   * @property {number}  UTF8   - Array of bytes representing a string of UTF8 encoded characters.
+   * @property {number}  UTF16  - Array of bytes representing a string of UTF16 encoded characters.
+   */
+  interface Type {
+    'STOP': number;
+    'VOID': number;
+    'BOOL': number;
+    'BYTE': number;
+    'I08': number;
+    'DOUBLE': number;
+    'I16': number;
+    'I32': number;
+    'I64': number;
+    'STRING': number;
+    'UTF7': number;
+    'STRUCT': number;
+    'MAP': number;
+    'SET': number;
+    'LIST': number;
+    'UTF8': number;
+    'UTF16': number;
+  }
+  var Type: Type;
+
+  /**
+   * Thrift RPC message type string to Id mapping.
+   * @property {number}  CALL      - RPC call sent from client to server.
+   * @property {number}  REPLY     - RPC call normal response from server to client.
+   * @property {number}  EXCEPTION - RPC call exception response from server to client.
+   * @property {number}  ONEWAY    - Oneway RPC call from client to server with no response.
+   */
+  interface MessageType {
+    'CALL': number;
+    'REPLY': number;
+    'EXCEPTION': number;
+    'ONEWAY': number;
+  }
+  var MessageType: MessageType;
+
+  /**
+   * Utility function returning the count of an object's own properties.
+   * @param {object} obj - Object to test.
+   * @returns {number} number of object's own properties
+   */
+  function objectLength(obj: any): number;
+
+  /**
+   * Utility function to establish prototype inheritance.
+   * @param {function} constructor - Contstructor function to set as derived.
+   * @param {function} superConstructor - Contstructor function to set as base.
+   * @param {string} [name] - Type name to set as name property in derived prototype.
+   */
+  function inherits(constructor: Function, superConstructor: Function, name?: string): void;
+
+  /**
+   * TException is the base class for all Thrift exceptions types.
+   */
+  class TException implements Error {
+    name: string;
+    message: string;
+
+    /**
+     * Initializes a Thrift TException instance.
+     * @param {string} message - The TException message (distinct from the Error message).
+     */
+    constructor(message: string);
+
+    /**
+     * Returns the message set on the exception.
+     * @returns {string} exception message
+     */
+    getMessage(): string;
+  }
+
+  /**
+   * Thrift Application Exception type string to Id mapping.
+   * @property {number}  UNKNOWN                 - Unknown/undefined.
+   * @property {number}  UNKNOWN_METHOD          - Client attempted to call a method unknown to the server.
+   * @property {number}  INVALID_MESSAGE_TYPE    - Client passed an unknown/unsupported MessageType.
+   * @property {number}  WRONG_METHOD_NAME       - Unused.
+   * @property {number}  BAD_SEQUENCE_ID         - Unused in Thrift RPC, used to flag proprietary sequence number errors.
+   * @property {number}  MISSING_RESULT          - Raised by a server processor if a handler fails to supply the required return result.
+   * @property {number}  INTERNAL_ERROR          - Something bad happened.
+   * @property {number}  PROTOCOL_ERROR          - The protocol layer failed to serialize or deserialize data.
+   * @property {number}  INVALID_TRANSFORM       - Unused.
+   * @property {number}  INVALID_PROTOCOL        - The protocol (or version) is not supported.
+   * @property {number}  UNSUPPORTED_CLIENT_TYPE - Unused.
+   */
+  interface TApplicationExceptionType {
+    'UNKNOWN': number;
+    'UNKNOWN_METHOD': number;
+    'INVALID_MESSAGE_TYPE': number;
+    'WRONG_METHOD_NAME': number;
+    'BAD_SEQUENCE_ID': number;
+    'MISSING_RESULT': number;
+    'INTERNAL_ERROR': number;
+    'PROTOCOL_ERROR': number;
+    'INVALID_TRANSFORM': number;
+    'INVALID_PROTOCOL': number;
+    'UNSUPPORTED_CLIENT_TYPE': number;
+  }
+  var TApplicationExceptionType: TApplicationExceptionType;
+
+  /**
+   * TApplicationException is the exception class used to propagate exceptions from an RPC server back to a calling client.
+   */
+  class TApplicationException extends TException {
+    code: number;
+
+    /**
+     * Initializes a Thrift TApplicationException instance.
+     * @param {string} message - The TApplicationException message (distinct from the Error message).
+     * @param {Thrift.TApplicationExceptionType} [code] - The TApplicationExceptionType code.
+     */
+    constructor(message: string, code?: number);
+
+    /**
+     * Read a TApplicationException from the supplied protocol.
+     * @param {object} input - The input protocol to read from.
+     */
+    read(input: any): void;
+
+    /**
+     * Write a TApplicationException to the supplied protocol.
+     * @param {object} output - The output protocol to write to.
+     */
+    write(output: any): void;
+
+    /**
+     * Returns the application exception code set on the exception.
+     * @returns {Thrift.TApplicationExceptionType} exception code
+     */
+    getCode(): number;
+  }
+
+  /**
+   * The Apache Thrift Transport layer performs byte level I/O between RPC
+   * clients and servers. The JavaScript Transport object type uses Http[s]/XHR and is
+   * the sole browser based Thrift transport. Target servers must implement the http[s] 
+   * transport (see: node.js example server).
+   */
+  class TXHRTransport {
+    url: string;
+    wpos: number;
+    rpos: number;
+    useCORS: any;
+    send_buf: string;
+    recv_buf: string;
+
+    /**
+     * If you do not specify a url then you must handle XHR operations on
+     * your own. This type can also be constructed using the Transport alias
+     * for backward compatibility.
+     * @param {string} [url] - The URL to connect to.
+     * @param {any} [options] - Options.
+     */
+    constructor(url?: string, options?: any);
+
+    /**
+     * Gets the browser specific XmlHttpRequest Object.
+     * @returns {object} the browser XHR interface object
+     */
+    getXmlHttpRequestObject(): any;
+
+    /**
+     * Sends the current XRH request if the transport was created with a URL and
+     * the async parameter if false. If the transport was not created with a URL
+     * or the async parameter is True or the URL is an empty string, the current 
+     * send buffer is returned.
+     * @param {object} async - If true the current send buffer is returned.
+     * @param {object} callback - Optional async completion callback.
+     * @returns {undefined|string} Nothing or the current send buffer.
+     */
+    flush(async: any, callback?: Function): string;
+
+    /**
+     * Creates a jQuery XHR object to be used for a Thrift server call.
+     * @param {object} client - The Thrift Service client object generated by the IDL compiler.
+     * @param {object} postData - The message to send to the server.
+     * @param {function} args - The function to call if the request suceeds.
+     * @param {function} recv_method - The Thrift Service Client receive method for the call.
+     * @returns {object} A new jQuery XHR object.
+     */
+    jqRequest(client: any, postData: any, args: Function, recv_method: Function): any;
+
+    /**
+     * Sets the buffer to use when receiving server responses.
+     * @param {string} buf - The buffer to receive server responses.
+     */
+    setRecvBuffer(buf: string): void;
+
+    /**
+     * Returns true if the transport is open, in browser based JavaScript
+     * this function always returns true.
+     * @returns {boolean} Always True.
+     */
+    isOpen(): boolean;
+
+    /**
+     * Opens the transport connection, in browser based JavaScript
+     * this function is a nop.
+     */
+    open(): void;
+
+    /**
+     * Closes the transport connection, in browser based JavaScript
+     * this function is a nop.
+     */
+    close(): void;
+
+    /**
+     * Returns the specified number of characters from the response
+     * buffer.
+     * @param {number} len - The number of characters to return.
+     * @returns {string} Characters sent by the server.
+     */
+    read(len: number): string;
+
+    /**
+     * Returns the entire response buffer.
+     * @returns {string} Characters sent by the server.
+     */
+    readAll(): string;
+
+    /**
+     * Sets the send buffer to buf.
+     * @param {string} buf - The buffer to send.
+     */
+    write(buf: string): void;
+
+    /**
+     * Returns the send buffer.
+     * @returns {string} The send buffer.
+     */
+    getSendBuffer(): string;
+  }
+
+  /**
+   * Old alias of the TXHRTransport for backwards compatibility.
+   */
+  class Transport extends TXHRTransport { }
+
+  /**
+   * The Apache Thrift Transport layer performs byte level I/O 
+   * between RPC clients and servers. The JavaScript TWebSocketTransport object 
+   * uses the WebSocket protocol. Target servers must implement WebSocket.
+   */
+  class TWebSocketTransport {
+    url: string;           //Where to connect
+    socket: any;           //The web socket
+    callbacks: any[];      //Pending callbacks
+    send_pending: any[];   //Buffers/Callback pairs waiting to be sent
+    send_buf: string;      //Outbound data, immutable until sent
+    recv_buf: string;      //Inbound data
+    rb_wpos: number;       //Network write position in receive buffer
+    rb_rpos: number;       //Client read position in receive buffer
+
+    /**
+     * Constructor Function for the WebSocket transport.
+     * @param {string } [url] - The URL to connect to.
+     */
+    constructor(url: string);
+
+    __reset(url): void;
+
+    /**
+     * Sends the current WS request and registers callback. The async 
+     * parameter is ignored (WS flush is always async) and the callback 
+     * function parameter is required.
+     * @param {object} async - Ignored.
+     * @param {object} callback - The client completion callback.
+     * @returns {undefined|string} Nothing (undefined) 
+     */
+    flush(async: any, callback: any): string;
+
+    __onOpen(): void;
+
+    __onClose(): void;
+
+    __onMessage(): void;
+
+    __onError(): void;
+
+    /**
+     * Sets the buffer to use when receiving server responses.
+     * @param {string} buf - The buffer to receive server responses.
+     */
+    setRecvBuffer(buf: string): void;
+
+    /**
+     * Returns true if the transport is open
+     * @returns {boolean} 
+     */
+    isOpen(): boolean;
+
+    /**
+     * Opens the transport connection
+     */
+    open(): void;
+
+    /**
+     * Closes the transport connection
+     */
+    close(): void;
+
+    /**
+     * Returns the specified number of characters from the response
+     * buffer.
+     * @param {number} len - The number of characters to return.
+     * @returns {string} Characters sent by the server.
+     */
+    read(len: number): string;
+
+    /**
+     * Returns the entire response buffer.
+     * @returns {string} Characters sent by the server.
+     */
+    readAll(): string;
+
+    /**
+     * Sets the send buffer to buf.
+     * @param {string} buf - The buffer to send.
+     */
+    write(buf: string): void;
+
+    /**
+     * Returns the send buffer.
+     * @returns {string} The send buffer.
+     */
+    getSendBuffer(): string;
+  }
+
+  /**
+   * Apache Thrift Protocols perform serialization which enables cross 
+   * language RPC. The Protocol type is the JavaScript browser implementation 
+   * of the Apache Thrift TJSONProtocol.
+   */
+  class TJSONProtocol {
+    transport: Transport;
+
+    /**
+     * Thrift IDL type Id to string mapping.
+     * The mapping table looks as follows:
+     * Thrift.Type.BOOL   -> "tf": True/False integer.
+     * Thrift.Type.BYTE   -> "i8": Signed 8 bit integer.
+     * Thrift.Type.I16    -> "i16": Signed 16 bit integer.
+     * Thrift.Type.I32    -> "i32": Signed 32 bit integer.
+     * Thrift.Type.I64    -> "i64": Signed 64 bit integer.
+     * Thrift.Type.DOUBLE -> "dbl": 64 bit IEEE 854 floating point.
+     * Thrift.Type.STRUCT -> "rec": A multifield type.
+     * Thrift.Type.STRING -> "str": Array of bytes representing a string of characters.
+     * Thrift.Type.MAP    -> "map": A collection type (map/associative-array/dictionary).
+     * Thrift.Type.LIST   -> "lst": A collection type (unordered).
+     * Thrift.Type.SET    -> "set": A collection type (unordered and without repeated values).
+     */
+    Type: { [k: number]: string };
+
+    /**
+     * Thrift IDL type string to Id mapping.
+     * The mapping table looks as follows:
+     * "tf"  -> Thrift.Type.BOOL  
+     * "i8"  -> Thrift.Type.BYTE  
+     * "i16" -> Thrift.Type.I16   
+     * "i32" -> Thrift.Type.I32   
+     * "i64" -> Thrift.Type.I64   
+     * "dbl" -> Thrift.Type.DOUBLE
+     * "rec" -> Thrift.Type.STRUCT
+     * "str" -> Thrift.Type.STRING
+     * "map" -> Thrift.Type.MAP   
+     * "lst" -> Thrift.Type.LIST  
+     * "set" -> Thrift.Type.SET   
+     */
+    RType: { [k: string]: number };
+
+    /**
+     * The TJSONProtocol version number.
+     */
+    Version: number;
+
+    /**
+     * Initializes a Thrift JSON protocol instance.
+     * @param {Thrift.Transport} transport - The transport to serialize to/from.
+     */
+    constructor(transport: Transport);
+
+    /**
+     * Returns the underlying transport.
+     * @returns {Thrift.Transport} The underlying transport.
+     */
+    getTransport(): Transport;
+
+    /**
+     * Serializes the beginning of a Thrift RPC message.
+     * @param {string} name - The service method to call.
+     * @param {Thrift.MessageType} messageType - The type of method call.
+     * @param {number} seqid - The sequence number of this call (always 0 in Apache Thrift).
+     */
+    writeMessageBegin(name: string, messageType: number, seqid: number): void;
+
+    /**
+     * Serializes the end of a Thrift RPC message.
+     */
+    writeMessageEnd(): void;
+
+    /**
+     * Serializes the beginning of a struct.
+     * @param {string} name - The name of the struct.
+     */
+    writeStructBegin(name?: string): void;
+
+    /**
+     * Serializes the end of a struct.
+     */
+    writeStructEnd(): void;
+
+    /**
+     * Serializes the beginning of a struct field.
+     * @param {string} name - The name of the field.
+     * @param {Thrift.Protocol.Type} fieldType - The data type of the field.
+     * @param {number} fieldId - The field's unique identifier.
+     */
+    writeFieldBegin(name: string, fieldType: string[], fieldId: number): void;
+
+    /**
+     * Serializes the end of a field.
+     */
+    writeFieldEnd(): void;
+
+    /**
+     * Serializes the end of the set of fields for a struct.
+     */
+    writeFieldStop(): void;
+
+    /**
+     * Serializes the beginning of a map collection.
+     * @param {Thrift.Type} keyType - The data type of the key.
+     * @param {Thrift.Type} valType - The data type of the value.
+     * @param {number} [size] - The number of elements in the map (ignored).
+     */
+    writeMapBegin(keyType: number, valType: number, size?: number): void;
+
+    /**
+     * Serializes the end of a map.
+     */
+    writeMapEnd(): void;
+
+    /**
+     * Serializes the beginning of a list collection.
+     * @param {Thrift.Type} elemType - The data type of the elements.
+     * @param {number} size - The number of elements in the list.
+     */
+    writeListBegin(elemType: number, size: number): void;
+
+    /**
+     * Serializes the end of a list.
+     */
+    writeListEnd(): void;
+
+    /**
+     * Serializes the beginning of a set collection.
+     * @param {Thrift.Type} elemType - The data type of the elements.
+     * @param {number} size - The number of elements in the list.
+     */
+    writeSetBegin(elemType: number, size: number): void;
+
+    /**
+     * Serializes the end of a set.
+     */
+    writeSetEnd(): void;
+
+    /** Serializes a boolean */
+    writeBool(value: boolean): void;
+
+    /** Serializes a number */
+    writeByte(i8: number): void;
+
+    /** Serializes a number */
+    writeI16(i16: number): void;
+
+    /** Serializes a number */
+    writeI32(i32: number): void;
+
+    /** Serializes a number */
+    writeI64(i64: number): void;
+
+    /** Serializes a number */
+    writeDouble(dbl: number): void;
+
+    /** Serializes a string */
+    writeString(str: string): void;
+
+    /** Serializes a string */
+    writeBinary(str: string): void;
+
+    /**
+       @class
+       @name AnonReadMessageBeginReturn
+       @property {string} fname - The name of the service method.
+       @property {Thrift.MessageType} mtype - The type of message call.
+       @property {number} rseqid - The sequence number of the message (0 in Thrift RPC).
+     */
+    /** 
+     * Deserializes the beginning of a message. 
+     * @returns {AnonReadMessageBeginReturn}
+     */
+    readMessageBegin(): { fname: string; mtype: number; rseqid: number };
+
+    /** Deserializes the end of a message. */
+    readMessageEnd(): void;
+
+    /** 
+     * Deserializes the beginning of a struct. 
+     * @param {string} [name] - The name of the struct (ignored).
+     * @returns {object} - An object with an empty string fname property.
+     */
+    readStructBegin(name?: string): any;
+
+    /** Deserializes the end of a struct. */
+    readStructEnd(): void;
+
+    /**
+       @class
+       @name AnonReadFieldBeginReturn
+       @property {string} fname - The name of the field (always '').
+       @property {Thrift.Type} ftype - The data type of the field.
+       @property {number} fid - The unique identifier of the field.
+     */
+    /** 
+     * Deserializes the beginning of a field. 
+     * @returns {AnonReadFieldBeginReturn}
+     */
+    readFieldBegin(): { fname: string; ftype: number; fid: number };
+
+    /** Deserializes the end of a field. */
+    readFieldEnd(): void;
+
+    /**
+       @class
+       @name AnonReadMapBeginReturn
+       @property {Thrift.Type} ktype - The data type of the key.
+       @property {Thrift.Type} vtype - The data type of the value.
+       @property {number} size - The number of elements in the map.
+     */
+    /** 
+     * Deserializes the beginning of a map. 
+     * @returns {AnonReadMapBeginReturn}
+     */
+    readMapBegin(): { ktype: number; vtype: number; size: number };
+
+    /** Deserializes the end of a map. */
+    readMapEnd(): void;
+
+    /**
+       @class
+       @name AnonReadColBeginReturn
+       @property {Thrift.Type} etype - The data type of the element.
+       @property {number} size - The number of elements in the collection.
+     */
+    /** 
+     * Deserializes the beginning of a list. 
+     * @returns {AnonReadColBeginReturn}
+     */
+    readListBegin(): { etype: number; size: number };
+
+    /** Deserializes the end of a list. */
+    readListEnd(): void;
+
+    /** 
+     * Deserializes the beginning of a set. 
+     * @param {Thrift.Type} elemType - The data type of the elements (ignored).
+     * @param {number} size - The number of elements in the list (ignored).
+     * @returns {AnonReadColBeginReturn}
+     */
+    readSetBegin(elemType?: number, size?: number): { etype: number; size: number };
+
+    /** Deserializes the end of a set. */
+    readSetEnd(): void;
+
+    /** Returns an object with a value property set to 
+     *  False unless the next number in the protocol buffer 
+     *  is 1, in which case the value property is True. */
+    readBool(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readByte(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readI16(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readI32(f?: any): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readI64(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readDouble(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readString(): Object;
+
+    /** Returns an object with a value property set to the 
+        next value found in the protocol buffer. */
+    readBinary(): Object;
+
+    /** 
+     * Method to arbitrarily skip over data (not implemented).
+     */
+    skip(type: any): void;
+  }
+
+  /**
+   * Old alias of the TXHRTransport for backwards compatibility.
+   */
+  class Protocol extends TJSONProtocol { }
+
+  class MultiplexProtocol extends Protocol {
+    serviceName: string;
+
+    /**
+     * Initializes a MutilplexProtocol Implementation as a Wrapper for Thrift.Protocol.
+     * @param {string} srvName
+     * @param {Thrift.Transport} trans
+     * @param {any} [strictRead]
+     * @param {any} [strictWrite]
+     */
+    constructor(srvName: string, trans: Transport, strictRead?: any, strictWrite?: any);
+  }
+
+  class Multiplexer {
+    seqid: number;
+
+    /** Instantiates a multiplexed client for a specific service.
+     * @param {String} serviceName - The transport to serialize to/from.
+     * @param {Thrift.ServiceClient} SCl - The Service Client Class.
+     * @param {Thrift.Transport} transport - Thrift.Transport instance which provides remote host:port.
+    */
+    createClient(serviceName: string, SCl: any, transport: Transport);
+  }
+}
\ No newline at end of file