diff --git a/google-protobuf/google-protobuf-tests.ts b/google-protobuf/google-protobuf-tests.ts
new file mode 100644
index 0000000000..796969b2b3
--- /dev/null
+++ b/google-protobuf/google-protobuf-tests.ts
@@ -0,0 +1,139 @@
+import * as jspb from "google-protobuf";
+
+/* This is a typescript version of a simple generated class from a proto file that is shown below. In order to make
+ this ES5 JS file into TypeScript there have been quite a few modifications, but the same calls are made to the library
+ classes.
+
+ // FILE: simple.proto
+ syntax = "proto3";
+
+ package examplecom;
+
+ message MySimple {
+   string my_string = 1;
+   bool my_bool = 2;
+   repeated string some_labels = 3;
+ }
+*/
+
+class MySimple extends jspb.Message {
+  constructor(opt_data?: any) {
+    super(); // This isn't actually called in the JS version of this file, but it's required by TS
+    jspb.Message.initialize(this, opt_data, 0, -1, MySimple.repeatedFields_, null);
+  };
+
+  static repeatedFields_ = [3];
+
+  toObject(opt_includeInstance: boolean) {
+    return MySimple.toObject(opt_includeInstance, this);
+  };
+
+  static toObject(includeInstance: boolean, msg: MySimple) {
+    const obj = {
+      myString: jspb.Message.getFieldWithDefault(msg, 1, ""),
+      myBool: jspb.Message.getFieldWithDefault(msg, 2, false),
+      someLabelsList: jspb.Message.getField(msg, 3),
+    };
+
+    if (includeInstance) {
+      // This is commented out because it's not valid in TS, but it's a simple append to an object
+      // obj['$jspbMessageInstance'] = msg;
+    }
+    return obj;
+  };
+
+  static deserializeBinary(bytes: Uint8Array) {
+    const reader = new jspb.BinaryReader(bytes);
+    const msg = new MySimple();
+    return MySimple.deserializeBinaryFromReader(msg, reader);
+  };
+
+  static deserializeBinaryFromReader(msg: MySimple, reader: jspb.BinaryReader) {
+    while (reader.nextField()) {
+      if (reader.isEndGroup()) {
+        break;
+      }
+      const field = reader.getFieldNumber();
+      switch (field) {
+        case 1:
+          const value1 = (reader.readString());
+          msg.setMyString(value1);
+          break;
+        case 2:
+          const value2 = (reader.readBool());
+          msg.setMyBool(value2);
+          break;
+        case 3:
+          const value3 = (reader.readString());
+          msg.addSomeLabels(value3);
+          break;
+        default:
+          reader.skipField();
+          break;
+      }
+    }
+    return msg;
+  };
+
+  serializeBinary(): Uint8Array {
+    const writer = new jspb.BinaryWriter();
+    MySimple.serializeBinaryToWriter(this, writer);
+    return writer.getResultBuffer();
+  };
+
+  static serializeBinaryToWriter(message: MySimple, writer: jspb.BinaryWriter) {
+    let f1 = message.getMyString();
+    if (f1.length > 0) {
+      writer.writeString(
+        1,
+        f1,
+      );
+    }
+    const f2 = message.getMyBool();
+    if (f2) {
+      writer.writeBool(
+        2,
+        f2,
+      );
+    }
+    const f3 = message.getSomeLabelsList();
+    if (f3.length > 0) {
+      writer.writeRepeatedString(
+        3,
+        f3,
+      );
+    }
+  }
+
+  getMyString(): string {
+    return jspb.Message.getFieldWithDefault(this, 1, "");
+  }
+
+  setMyString(value: string) {
+    jspb.Message.setField(this, 1, value);
+  }
+
+  getMyBool(): boolean {
+    return jspb.Message.getFieldWithDefault(this, 2, false);
+  }
+
+  setMyBool(value: boolean) {
+    jspb.Message.setField(this, 2, value);
+  }
+
+  getSomeLabelsList(): string[] {
+    return jspb.Message.getField(this, 3);
+  }
+
+  setSomeLabelsList(value: string[]) {
+    jspb.Message.setField(this, 3, value || []);
+  }
+
+  addSomeLabels(value: string, opt_index?: number) {
+    jspb.Message.addToRepeatedField(this, 3, value, opt_index);
+  }
+
+  clearSomeLabelsList() {
+    this.setSomeLabelsList([]);
+  }
+}
diff --git a/google-protobuf/index.d.ts b/google-protobuf/index.d.ts
new file mode 100644
index 0000000000..f40780ed8a
--- /dev/null
+++ b/google-protobuf/index.d.ts
@@ -0,0 +1,675 @@
+// Type definitions for google-protobuf 3.2
+// Project: https://github.com/google/google-protobuf
+// Definitions by: Marcus Longmuir <https://github.com/marcuslongmuir/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+type ByteSource = ArrayBuffer|Uint8Array|number[]|string;
+type ScalarFieldType = boolean|number|string;
+type RepeatedFieldType = ScalarFieldType[] | Uint8Array[];
+type AnyFieldType = ScalarFieldType | RepeatedFieldType | Uint8Array;
+type FieldValue = (string|number|boolean|Uint8Array|any/*This should be Array<FieldValue>, but that isn't allowed*/|undefined)
+
+export class Message {
+  getJsPbMessageId(): (string | undefined);
+  static initialize(msg: Message,
+                    data: Message.MessageArray,
+                    messageId: (string | number),
+                    suggestedPivot: number,
+                    repeatedFields: number[],
+                    oneofFields?: number[][] | null): void;
+  static toObjectList<T extends Message>(field: T[],
+                                         toObjectFn: (includeInstance: boolean,
+                                                      data: T) => {},
+                                         includeInstance?: boolean): {}[];
+  static toObjectExtension(msg: Message,
+                           obj: {},
+                           extensions: {[key: number]: ExtensionFieldInfo<Message>},
+                           getExtensionFn: (fieldInfo: ExtensionFieldInfo<Message>) => Message,
+                           includeInstance?: boolean): void;
+  serializeBinaryExtensions(proto: Message,
+                            writer: BinaryWriter,
+                            extensions: {[key: number]: ExtensionFieldBinaryInfo<Message>},
+                            getExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>) => T): void
+  readBinaryExtension(proto: Message,
+                      reader: BinaryReader,
+                      extensions: {[key: number]: ExtensionFieldBinaryInfo<Message>},
+                      setExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>,
+                                          val: T) => void): void
+  static getField(msg: Message,
+                  fieldNumber: number): FieldValue|null;
+  static getOptionalFloatingPointField(msg: Message,
+                                       fieldNumber: number): (number | undefined);
+  static getRepeatedFloatingPointField(msg: Message,
+                                       fieldNumber: number): number[];
+  static bytesAsB64(bytes: Uint8Array): string;
+  static bytesAsU8(str: string): Uint8Array;
+  static bytesListAsB64(bytesList: Uint8Array[]): string[];
+  static bytesListAsU8(strList: string[]): Uint8Array[];
+  static getFieldWithDefault<T>(msg: Message,
+                                fieldNumber: number,
+                                defaultValue: T): T;
+  static getMapField(msg: Message,
+                     fieldNumber: number,
+                     noLazyCreate: boolean,
+                     valueCtor: typeof Message): Map<any, any>;
+  static setField(msg: Message,
+                  fieldNumber: number,
+                  value: FieldValue): void;
+  static addToRepeatedField(msg: Message,
+                            fieldNumber: number,
+                            value: any,
+                            index?: number): void;
+  static setOneofField(msg: Message,
+                       fieldNumber: number,
+                       oneof: number[],
+                       value: FieldValue): void;
+  static computeOneofCase(msg: Message,
+                          oneof: number[]): number;
+  static getWrapperField(msg: Message,
+                         ctor: typeof Message,
+                         fieldNumber: number,
+                         required?: number): Message;
+  static getRepeatedWrapperField(msg: Message,
+                                 ctor: typeof Message,
+                                 fieldNumber: number): Message[];
+  static setWrapperField(msg: Message,
+                         fieldNumber: number,
+                         value?: (Message|Map<any, any>)): void;
+  static setOneofWrapperField(msg: Message,
+                              fieldNumber: number,
+                              oneof: number[],
+                              value: any): void;
+  static setRepeatedWrapperField(msg: Message,
+                                 fieldNumber: number,
+                                 value: any): void;
+  static addToRepeatedWrapperField(msg: Message,
+                                   fieldNumber: number,
+                                   value: any,
+                                   ctor: typeof Message,
+                                   index: number): any;
+  static toMap(field: any[],
+               mapKeyGetterFn: (field: any) => string,
+               toObjectFn?: Message.StaticToObject,
+               includeInstance?: boolean): void;
+  toArray(): Message.MessageArray;
+  toString(): string;
+  getExtension<T>(fieldInfo: ExtensionFieldInfo<T>): T;
+  setExtension<T>(fieldInfo: ExtensionFieldInfo<T>,
+                  value: T): void;
+  static difference<T extends Message>(m1: T,
+                                       m2: T): T;
+  static equals(m1: Message,
+                m2: Message): boolean;
+  static compareExtensions(extension1: {},
+                           extension2: {}): boolean;
+  static compareFields(field1: any,
+                       field2: any): boolean;
+  cloneMessage(): Message;
+  clone(): Message;
+  static clone<T extends Message>(msg: T): T;
+  static cloneMessage<T extends Message>(msg: T): T;
+  static copyInto(fromMessage: Message,
+                  toMessage: Message): void;
+  static registerMessageType(id: number,
+                             constructor: typeof Message): void;
+}
+
+export namespace Message {
+  export type MessageArray = any[]; // This type needs to reference itself
+  interface StaticToObject {
+    (includeInstance: boolean,
+     msg: Message): {};
+  }
+}
+
+export class ExtensionFieldInfo<T> {
+  fieldIndex: number;
+  fieldName: number;
+  ctor: typeof Message;
+  toObjectFn: Message.StaticToObject;
+  isRepeated: number;
+  constructor(fieldIndex: number,
+              fieldName: {[key: string]: number},
+              ctor: typeof Message,
+              toObjectFn: Message.StaticToObject,
+              isRepeated: number);
+  isMessageType(): boolean;
+}
+
+export class ExtensionFieldBinaryInfo<T> {
+  fieldInfo: ExtensionFieldInfo<T>;
+  binaryReaderFn: BinaryRead;
+  binaryWriterFn: BinaryWrite;
+  opt_binaryMessageSerializeFn: (msg: Message,
+                                 writer: BinaryWriter) => void;
+  opt_binaryMessageDeserializeFn: (msg: Message,
+                                   reader: BinaryReader) => Message;
+  opt_isPacked: boolean;
+  constructor(fieldInfo: ExtensionFieldInfo<T>,
+              binaryReaderFn: BinaryRead,
+              binaryWriterFn: BinaryWrite,
+              opt_binaryMessageSerializeFn: (msg: Message,
+                                             writer: BinaryWriter) => void,
+              opt_binaryMessageDeserializeFn: (msg: Message,
+                                               reader: BinaryReader) => Message,
+              opt_isPacked: boolean);
+}
+
+export class Map<K, V> {
+  constructor(arr: Array<[K, V]>,
+              valueCtor?: {new(init: any): V});
+  toArray(): Array<[K, V]>;
+  toObject(includeInstance: boolean,
+           valueToObject: (includeInstance: boolean) => any): Array<[K, V]>;
+  static fromObject<K, V>(entries: Array<[K, V]>,
+                          valueCtor: any,
+                          valueFromObject: any): Map<K, V>;
+  getLength(): number;
+  clear(): void;
+  del(key: K): boolean;
+  getEntryList(): Array<[K, V]>;
+  entries(): Map.Iterator<[K, V]>;
+  keys(): Map.Iterator<K>;
+  forEach(callback: (entry: V,
+                     key: K) => void,
+          thisArg?: {}): void;
+  set(key: K,
+      value: V): void;
+  get(key: K): (V | undefined);
+  has(key: K): boolean;
+}
+
+export namespace Map {
+  // This is implemented by jspb.Map.ArrayIteratorIterable_, but that class shouldn't be exported
+  interface Iterator<T> {
+    next(): IteratorResult<T>;
+  }
+  type IteratorResult<T> = {
+    done: boolean,
+    value: T,
+  }
+}
+
+interface BinaryReadReader {
+  (msg: any,
+   binaryReader: BinaryReader): void;
+}
+
+interface BinaryRead {
+  (msg: any,
+   reader: BinaryReadReader): void;
+}
+
+interface BinaryWriteCallback {
+  (value: any,
+   binaryWriter: BinaryWriter): void;
+}
+
+interface BinaryWrite {
+  (fieldNumber: number,
+   value: any,
+   writerCallback: BinaryWriteCallback): void;
+}
+
+export class BinaryReader {
+  constructor(bytes?: ByteSource,
+              start?: number,
+              length?: number);
+  static alloc(bytes?: ByteSource,
+               start?: number,
+               length?: number): BinaryReader;
+  alloc(bytes?: ByteSource,
+        start?: number,
+        length?: number): BinaryReader;
+  free(): void;
+  getFieldCursor(): number;
+  getCursor(): number;
+  getBuffer(): Uint8Array;
+  getFieldNumber(): number;
+  getWireType(): BinaryConstants.WireType;
+  isEndGroup(): boolean;
+  getError(): boolean;
+  setBlock(bytes?: ByteSource,
+           start?: number,
+           length?: number): void;
+  reset(): void;
+  advance(count: number): void;
+  nextField(): boolean;
+  unskipHeader(): void;
+  skipMatchingFields(): void;
+  skipVarintField(): void;
+  skipDelimitedField(): void;
+  skipFixed32Field(): void;
+  skipFixed64Field(): void;
+  skipGroup(): void;
+  skipField(): void;
+  registerReadCallback(callbackName: string,
+                       callback: (binaryReader: BinaryReader) => any): void;
+  runReadCallback(callbackName: string): any;
+  readAny(fieldType: BinaryConstants.FieldType): AnyFieldType;
+  readMessage: BinaryRead;
+  readGroup(field: number,
+            message: Message,
+            reader: BinaryReadReader): void;
+  getFieldDecoder(): BinaryDecoder;
+  readInt32(): number;
+  readInt32String(): string;
+  readInt64(): number;
+  readInt64String(): string;
+  readUint32(): number;
+  readUint32String(): string;
+  readUint64(): number;
+  readUint64String(): string;
+  readSint32(): number;
+  readSint64(): number;
+  readSint64String(): string;
+  readFixed32(): number;
+  readFixed64(): number;
+  readFixed64String(): string;
+  readSfixed32(): number;
+  readSfixed32String(): string;
+  readSfixed64(): number;
+  readSfixed64String(): string;
+  readFloat(): number;
+  readDouble(): number;
+  readBool(): boolean;
+  readEnum(): number;
+  readString(): string;
+  readBytes(): Uint8Array;
+  readVarintHash64(): string;
+  readFixedHash64(): string;
+  readPackedInt32(): number[];
+  readPackedInt32String(): string[];
+  readPackedInt64(): number[];
+  readPackedInt64String(): string[];
+  readPackedUint32(): number[];
+  readPackedUint32String(): string[];
+  readPackedUint64(): number[];
+  readPackedUint64String(): string[];
+  readPackedSint32(): number[];
+  readPackedSint64(): number[];
+  readPackedSint64String(): string[];
+  readPackedFixed32(): number[];
+  readPackedFixed64(): number[];
+  readPackedFixed64String(): string[];
+  readPackedSfixed32(): number[];
+  readPackedSfixed64(): number[];
+  readPackedSfixed64String(): string[];
+  readPackedFloat(): number[];
+  readPackedDouble(): number[];
+  readPackedBool(): boolean[];
+  readPackedEnum(): number[];
+  readPackedVarintHash64(): string[];
+  readPackedFixedHash64(): string[];
+}
+
+export class BinaryWriter {
+  constructor();
+  writeSerializedMessage(bytes: Uint8Array,
+                         start: number,
+                         end: number): void;
+  maybeWriteSerializedMessage(bytes?: Uint8Array,
+                              start?: number,
+                              end?: number): void;
+  reset(): void;
+  getResultBuffer(): Uint8Array;
+  getResultBase64String(): string;
+  beginSubMessage(field: number): void;
+  endSubMessage(field: number): void;
+  writeAny(fieldType: BinaryConstants.FieldType,
+           field: number,
+           value: AnyFieldType): void;
+  writeInt32(field: number,
+             value?: number): void;
+  writeInt32String(field: number,
+                   value?: string): void;
+  writeInt64(field: number,
+             value?: number): void;
+  writeInt64String(field: number,
+                   value?: string): void;
+  writeUint32(field: number,
+              value?: number): void;
+  writeUint32String(field: number,
+                    value?: string): void;
+  writeUint64(field: number,
+              value?: number): void;
+  writeUint64String(field: number,
+                    value?: string): void;
+  writeSint32(field: number,
+              value?: number): void;
+  writeSint64(field: number,
+              value?: number): void;
+  writeSint64String(field: number,
+                    value?: string): void;
+  writeFixed32(field: number,
+               value?: number): void;
+  writeFixed64(field: number,
+               value?: number): void;
+  writeFixed64String(field: number,
+                     value?: string): void;
+  writeSfixed32(field: number,
+                value?: number): void;
+  writeSfixed64(field: number,
+                value?: number): void;
+  writeSfixed64String(field: number,
+                      value?: string): void;
+  writeFloat(field: number,
+             value?: number): void;
+  writeDouble(field: number,
+              value?: number): void;
+  writeBool(field: number,
+            value?: boolean): void;
+  writeEnum(field: number,
+            value?: number): void;
+  writeString(field: number,
+              value?: string): void;
+  writeBytes(field: number,
+             value?: ByteSource): void;
+  writeMessage: BinaryWrite;
+  writeGroup(field: number,
+             value: any,
+             writeCallback: BinaryWriteCallback): void;
+  writeFixedHash64(field: number,
+                   value?: string): void;
+  writeVarintHash64(field: number,
+                    value?: string): void;
+  writeRepeatedInt32(field: number,
+                     value?: number[]): void;
+  writeRepeatedInt32String(field: number,
+                           value?: string[]): void;
+  writeRepeatedInt64(field: number,
+                     value?: number[]): void;
+  writeRepeatedInt64String(field: number,
+                           value?: string[]): void;
+  writeRepeatedUint32(field: number,
+                      value?: number[]): void;
+  writeRepeatedUint32String(field: number,
+                            value?: string[]): void;
+  writeRepeatedUint64(field: number,
+                      value?: number[]): void;
+  writeRepeatedUint64String(field: number,
+                            value?: string[]): void;
+  writeRepeatedSint32(field: number,
+                      value?: number[]): void;
+  writeRepeatedSint64(field: number,
+                      value?: number[]): void;
+  writeRepeatedSint64String(field: number,
+                            value?: string[]): void;
+  writeRepeatedFixed32(field: number,
+                       value?: number[]): void;
+  writeRepeatedFixed64(field: number,
+                       value?: number[]): void;
+  writeRepeatedFixed64String(field: number,
+                             value?: string[]): void;
+  writeRepeatedSfixed32(field: number,
+                        value?: number[]): void;
+  writeRepeatedSfixed64(field: number,
+                        value?: number[]): void;
+  writeRepeatedSfixed64String(field: number,
+                              value?: string[]): void;
+  writeRepeatedFloat(field: number,
+                     value?: number[]): void;
+  writeRepeatedDouble(field: number,
+                      value?: number[]): void;
+  writeRepeatedBool(field: number,
+                    value?: boolean[]): void;
+  writeRepeatedEnum(field: number,
+                    value?: number[]): void;
+  writeRepeatedString(field: number,
+                      value?: string[]): void;
+  writeRepeatedBytes(field: number,
+                     value?: ByteSource[]): void;
+  writeRepeatedMessage(field: number,
+                       value: Message[],
+                       writerCallback: BinaryWriteCallback): void;
+  writeRepeatedGroup(field: number,
+                     value: Message[],
+                     writerCallback: BinaryWriteCallback): void;
+  writeRepeatedFixedHash64(field: number,
+                           value?: string[]): void;
+  writeRepeatedVarintHash64(field: number,
+                            value?: string[]): void;
+  writePackedInt32(field: number,
+                   value?: number[]): void;
+  writePackedInt32String(field: number,
+                         value?: string[]): void;
+  writePackedInt64(field: number,
+                   value?: number[]): void;
+  writePackedInt64String(field: number,
+                         value?: string[]): void;
+  writePackedUint32(field: number,
+                    value?: number[]): void;
+  writePackedUint32String(field: number,
+                          value?: string[]): void;
+  writePackedUint64(field: number,
+                    value?: number[]): void;
+  writePackedUint64String(field: number,
+                          value?: string[]): void;
+  writePackedSint32(field: number,
+                    value?: number[]): void;
+  writePackedSint64(field: number,
+                    value?: number[]): void;
+  writePackedSint64String(field: number,
+                          value?: string[]): void;
+  writePackedFixed32(field: number,
+                     value?: number[]): void;
+  writePackedFixed64(field: number,
+                     value?: number[]): void;
+  writePackedFixed64String(field: number,
+                           value?: string[]): void;
+  writePackedSfixed32(field: number,
+                      value?: number[]): void;
+  writePackedSfixed64(field: number,
+                      value?: number[]): void;
+  writePackedSfixed64String(field: number,
+                            value?: string[]): void;
+  writePackedFloat(field: number,
+                   value?: number[]): void;
+  writePackedDouble(field: number,
+                    value?: number[]): void;
+  writePackedBool(field: number,
+                  value?: boolean[]): void;
+  writePackedEnum(field: number,
+                  value?: number[]): void;
+  writePackedFixedHash64(field: number,
+                         value?: string[]): void;
+  writePackedVarintHash64(field: number,
+                          value?: string[]): void;
+}
+
+export class BinaryEncoder {
+  constructor();
+  length(): number;
+  end(): number[];
+  writeSplitVarint64(lowBits: number,
+                     highBits: number): void;
+  writeSplitFixed64(lowBits: number,
+                    highBits: number): void;
+  writeUnsignedVarint32(value: number): void;
+  writeSignedVarint32(value: number): void;
+  writeUnsignedVarint64(value: number): void;
+  writeSignedVarint64(value: number): void;
+  writeZigzagVarint32(value: number): void;
+  writeZigzagVarint64(value: number): void;
+  writeZigzagVarint64String(value: string): void;
+  writeUint8(value: number): void;
+  writeUint16(value: number): void;
+  writeUint32(value: number): void;
+  writeUint64(value: number): void;
+  writeInt8(value: number): void;
+  writeInt16(value: number): void;
+  writeInt32(value: number): void;
+  writeInt64(value: number): void;
+  writeInt64String(value: string): void;
+  writeFloat(value: number): void;
+  writeDouble(value: number): void;
+  writeBool(value: boolean): void;
+  writeEnum(value: number): void;
+  writeBytes(bytes: Uint8Array): void;
+  writeVarintHash64(hash: string): void;
+  writeFixedHash64(hash: string): void;
+  writeString(value: string): number;
+}
+
+export class BinaryDecoder {
+  constructor(bytes?: ByteSource,
+              start?: number,
+              length?: number)
+  static alloc(bytes?: ByteSource,
+               start?: number,
+               length?: number): BinaryDecoder;
+  free(): void;
+  clone(): BinaryDecoder;
+  clear(): void;
+  getBuffer(): Uint8Array;
+  setBlock(data: ByteSource,
+           start?: number,
+           length?: number): void;
+  getEnd(): number;
+  setEnd(end: number): void;
+  reset(): void;
+  getCursor(): number;
+  setCursor(cursor: number): void;
+  advance(count: number): void;
+  atEnd(): boolean;
+  pastEnd(): boolean;
+  getError(): boolean;
+  skipVarint(): void;
+  unskipVarint(value: number): void;
+  readUnsignedVarint32(): number;
+  readSignedVarint32(): number;
+  readUnsignedVarint32String(): number;
+  readSignedVarint32String(): number;
+  readZigzagVarint32(): number;
+  readUnsignedVarint64(): number;
+  readUnsignedVarint64String(): number;
+  readSignedVarint64(): number;
+  readSignedVarint64String(): number;
+  readZigzagVarint64(): number;
+  readZigzagVarint64String(): number;
+  readUint8(): number;
+  readUint16(): number;
+  readUint32(): number;
+  readUint64(): number;
+  readUint64String(): string;
+  readInt8(): number;
+  readInt16(): number;
+  readInt32(): number;
+  readInt64(): number;
+  readInt64String(): string;
+  readFloat(): number;
+  readDouble(): number;
+  readBool(): boolean;
+  readEnum(): number;
+  readString(length: number): string;
+  readStringWithLength(): string;
+  readBytes(length: number): Uint8Array;
+  readVarintHash64(): string;
+  readFixedHash64(): string;
+}
+
+export class BinaryIterator {
+  constructor(decoder?: BinaryDecoder,
+              next?: () => number|boolean|string|null,
+              elements?: Array<number|boolean|string>)
+  static alloc(decoder?: BinaryDecoder,
+               next?: () => number|boolean|string|null,
+               elements?: Array<number|boolean|string>): BinaryIterator;
+  free(): void;
+  clear(): void;
+  get(): (ScalarFieldType | null);
+  atEnd(): boolean;
+  next(): (ScalarFieldType | null);
+}
+
+export namespace BinaryConstants {
+  export enum FieldType {
+    INVALID = -1,
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    GROUP = 10,
+    MESSAGE = 11,
+    BYTES = 12,
+    UINT32 = 13,
+    ENUM = 14,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,
+    SINT64 = 18,
+    FHASH64 = 30,
+    VHASH64 = 31,
+  }
+
+  export enum WireType {
+    INVALID = -1,
+    VARINT = 0,
+    FIXED64 = 1,
+    DELIMITED = 2,
+    START_GROUP = 3,
+    END_GROUP = 4,
+    FIXED32 = 5,
+  }
+
+  const FieldTypeToWireType: (fieldType: FieldType) => WireType;
+
+  const INVALID_FIELD_NUMBER: number;
+  const FLOAT32_EPS: number;
+  const FLOAT32_MIN: number;
+  const FLOAT32_MAX: number;
+  const FLOAT64_EPS: number;
+  const FLOAT64_MIN: number;
+  const FLOAT64_MAX: number;
+  const TWO_TO_20: number;
+  const TWO_TO_23: number;
+  const TWO_TO_31: number;
+  const TWO_TO_32: number;
+  const TWO_TO_52: number;
+  const TWO_TO_63: number;
+  const TWO_TO_64: number;
+  const ZERO_HASH: string;
+}
+
+export namespace arith {
+  export class UInt64 {
+    lo: number;
+    hi: number;
+    constructor(lo: number,
+                hi: number);
+    cmp(other: UInt64): number;
+    rightShift(): UInt64;
+    leftShift(): UInt64;
+    msb(): boolean;
+    lsb(): boolean;
+    zero(): boolean;
+    add(other: UInt64): UInt64;
+    sub(other: UInt64): UInt64;
+    static mul32x32(a: number,
+                    b: number): UInt64;
+    mul(a: number): UInt64;
+    div(divisor: number): [UInt64, UInt64];
+    toString(): string;
+    static fromString(str: string): UInt64;
+    clone(): UInt64;
+  }
+
+  export class Int64 {
+    lo: number;
+    hi: number;
+    constructor(lo: number,
+                hi: number);
+    add(other: Int64): Int64;
+    sub(other: Int64): Int64;
+    clone(): Int64;
+    toString(): string;
+    static fromString(str: string): Int64;
+  }
+}
+
+// jspb.utils package excluded as it likely shouldn't be called by user code
\ No newline at end of file
diff --git a/google-protobuf/tsconfig.json b/google-protobuf/tsconfig.json
new file mode 100644
index 0000000000..269fec20d9
--- /dev/null
+++ b/google-protobuf/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": [
+      "es6"
+    ],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "index.d.ts",
+    "google-protobuf-tests.ts"
+  ]
+}
\ No newline at end of file
diff --git a/google-protobuf/tslint.json b/google-protobuf/tslint.json
new file mode 100644
index 0000000000..fdc7cdc370
--- /dev/null
+++ b/google-protobuf/tslint.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../tslint.json"
+}
\ No newline at end of file