@types/google-protobuf/index.d.ts

// Type definitions for google-protobuf 3.15
// Project: https://github.com/google/google-protobuf
// Definitions by: Marcus Longmuir <https://github.com/marcuslongmuir>
//                 Chaitanya Kamatham <https://github.com/kamthamc>
// 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 | FieldValueArray | undefined;
interface FieldValueArray extends Array<FieldValue> {}

export abstract class Message {
    getJsPbMessageId(): string | undefined;
    static initialize(
        msg: Message,
        data: Message.MessageArray,
        messageId: string | number,
        suggestedPivot: number,
        repeatedFields?: number[] | null,
        oneofFields?: number[][] | null,
    ): void;
    static toObjectList<T extends Message>(
        field: T[],
        toObjectFn: (includeInstance: boolean, data: T) => {},
        includeInstance?: boolean,
    ): Array<{}>;
    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<T extends Message>(
        msg: Message,
        ctor: { new(): T },
        fieldNumber: number,
        required?: number,
    ): T;
    static getRepeatedWrapperField<T extends Message>(
        msg: Message,
        ctor: { new(): T },
        fieldNumber: number,
    ): T[];
    static setWrapperField<T extends Message>(
        msg: Message,
        fieldNumber: number,
        value?: T | Map<any, any>,
    ): void;
    static setOneofWrapperField(
        msg: Message,
        fieldNumber: number,
        oneof: number[],
        value: any,
    ): void;
    static setRepeatedWrapperField<T extends Message>(
        msg: Message,
        fieldNumber: number,
        value?: T[],
    ): void;
    static addToRepeatedWrapperField<T extends Message>(
        msg: Message,
        fieldNumber: number,
        value: T | undefined,
        ctor: { new(): T },
        index?: number,
    ): T;
    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(): this;
    clone(): this;
    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 {
    type MessageArray = any[]; // This type needs to reference itself
    type 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): Array<[K, V]>;
    toObject<VO>(
        includeInstance: boolean,
        valueToObject: (includeInstance: boolean, valueWrapper: V) => VO,
    ): Array<[K, VO]>;
    static fromObject<TK, TV>(
        entries: Array<[TK, TV]>,
        valueCtor: any,
        valueFromObject: any,
    ): Map<TK, TV>;
    getLength(): number;
    clear(): void;
    del(key: K): boolean;
    getEntryList(): Array<[K, V]>;
    entries(): Map.Iterator<[K, V]>;
    keys(): Map.Iterator<K>;
    values(): Map.Iterator<V>;
    forEach(
        callback: (entry: V, key: K) => void,
        thisArg?: {},
    ): void;
    set(key: K, value: V): this;
    get(key: K): V | undefined;
    has(key: K): boolean;
    serializeBinary(
        fieldNumber: number,
        writer: BinaryWriter,
        keyWriterFn: (field: number, key: K) => void,
        valueWriterFn: (field: number, value: V, writerCallback: BinaryWriteCallback) => void,
        writeCallback?: BinaryWriteCallback,
    ): void;
    static deserializeBinary<K, V>(
        map: Map<K, V>,
        reader: BinaryReader,
        keyReaderFn: (reader: BinaryReader) => K,
        valueReaderFn: (reader: BinaryReader, value: any, readerCallback: BinaryReadCallback) => V,
        readCallback?: BinaryReadCallback,
        defaultKey?: K,
        defaultValue?: V,
    ): void;
}

export namespace Map {
    // This is implemented by jspb.Map.ArrayIteratorIterable_, but that class shouldn't be exported
    interface Iterator<T> {
        [Symbol.iterator](): Iterator<T>;
        next(): IteratorResult<T>;
    }
    interface IteratorResult<T> {
        done: boolean;
        value: T;
    }
}

type BinaryReadReader = (msg: any, binaryReader: BinaryReader) => void;

type BinaryRead = (msg: any, reader: BinaryReadReader) => any;

type BinaryReadCallback = (value: any, binaryReader: BinaryReader) => void;

type BinaryWriteCallback = (value: any, binaryWriter: BinaryWriter) => void;

type 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;
    isDelimited(): boolean;
    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 {
    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,
    }

    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 {
    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;
    }

    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