// 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 abstract 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;

  abstract serializeBinary(): Uint8Array;
  abstract toObject(includeInstance?: boolean): {};

  // These are `abstract static`, but that isn't allowed. Subclasses of Message will have these methods and properties
  // and not having them on Message makes using this class for its intended purpose quite difficult.
  static deserializeBinary(bytes: Uint8Array): Message;
  static deserializeBinaryFromReader(message: Message, reader: BinaryReader): Message;
  static serializeBinaryToWriter(message: Message, writer: BinaryWriter): void;
  static toObject(includeInstance: boolean, msg: Message): {};
  static extensions: {[key: number]: ExtensionFieldInfo<Message>};
  static extensionsBinary: {[key: number]: ExtensionFieldBinaryInfo<Message>};
}

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