// Type definitions for google-protobuf 3.2
// Project: https://github.com/google/google-protobuf
// Definitions by: Marcus Longmuir
// 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, 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(field: T[],
toObjectFn: (includeInstance: boolean,
data: T) => {},
includeInstance?: boolean): {}[];
static toObjectExtension(msg: Message,
obj: {},
extensions: {[key: number]: ExtensionFieldInfo},
getExtensionFn: (fieldInfo: ExtensionFieldInfo) => Message,
includeInstance?: boolean): void;
serializeBinaryExtensions(proto: Message,
writer: BinaryWriter,
extensions: {[key: number]: ExtensionFieldBinaryInfo},
getExtensionFn: (fieldInfo: ExtensionFieldInfo) => T): void
readBinaryExtension(proto: Message,
reader: BinaryReader,
extensions: {[key: number]: ExtensionFieldBinaryInfo},
setExtensionFn: (fieldInfo: ExtensionFieldInfo,
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(msg: Message,
fieldNumber: number,
defaultValue: T): T;
static getMapField(msg: Message,
fieldNumber: number,
noLazyCreate: boolean,
valueCtor: typeof Message): Map;
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)): 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(fieldInfo: ExtensionFieldInfo): T;
setExtension(fieldInfo: ExtensionFieldInfo,
value: T): void;
static difference(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(msg: T): T;
static cloneMessage(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 {
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 {
fieldInfo: ExtensionFieldInfo;
binaryReaderFn: BinaryRead;
binaryWriterFn: BinaryWrite;
opt_binaryMessageSerializeFn: (msg: Message,
writer: BinaryWriter) => void;
opt_binaryMessageDeserializeFn: (msg: Message,
reader: BinaryReader) => Message;
opt_isPacked: boolean;
constructor(fieldInfo: ExtensionFieldInfo,
binaryReaderFn: BinaryRead,
binaryWriterFn: BinaryWrite,
opt_binaryMessageSerializeFn: (msg: Message,
writer: BinaryWriter) => void,
opt_binaryMessageDeserializeFn: (msg: Message,
reader: BinaryReader) => Message,
opt_isPacked: boolean);
}
export class Map {
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(entries: Array<[K, V]>,
valueCtor: any,
valueFromObject: any): Map;
getLength(): number;
clear(): void;
del(key: K): boolean;
getEntryList(): Array<[K, V]>;
entries(): Map.Iterator<[K, V]>;
keys(): Map.Iterator;
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 {
next(): IteratorResult;
}
type IteratorResult = {
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)
static alloc(decoder?: BinaryDecoder,
next?: () => number|boolean|string|null,
elements?: Array): 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