@types/google-protobuf

Version 3.15.6
Published 10 months ago
110 kB
No dependencies
MIT license

Install

npm i @types/google-protobuf

yarn add @types/google-protobuf

pnpm add @types/google-protobuf

Overview

TypeScript definitions for google-protobuf

Index

Classes

class BinaryDecoder

class BinaryDecoder {}

constructor

constructor(bytes?: ByteSource, start?: number, length?: number);

method advance

advance: (count: number) => void;

method alloc

static alloc: (
    bytes?: ByteSource,
    start?: number,
    length?: number
) => BinaryDecoder;

method atEnd

atEnd: () => boolean;

method clear

clear: () => void;

method clone

clone: () => BinaryDecoder;

method free

free: () => void;

method getBuffer

getBuffer: () => Uint8Array;

method getCursor

getCursor: () => number;

method getEnd

getEnd: () => number;

method getError

getError: () => boolean;

method pastEnd

pastEnd: () => boolean;

method readBool

readBool: () => boolean;

method readBytes

readBytes: (length: number) => Uint8Array;

method readDouble

readDouble: () => number;

method readEnum

readEnum: () => number;

method readFixedHash64

readFixedHash64: () => string;

method readFloat

readFloat: () => number;

method readInt16

readInt16: () => number;

method readInt32

readInt32: () => number;

method readInt64

readInt64: () => number;

method readInt64String

readInt64String: () => string;

method readInt8

readInt8: () => number;

method readSignedVarint32

readSignedVarint32: () => number;

method readSignedVarint32String

readSignedVarint32String: () => number;

method readSignedVarint64

readSignedVarint64: () => number;

method readSignedVarint64String

readSignedVarint64String: () => number;

method readString

readString: (length: number) => string;

method readStringWithLength

readStringWithLength: () => string;

method readUint16

readUint16: () => number;

method readUint32

readUint32: () => number;

method readUint64

readUint64: () => number;

method readUint64String

readUint64String: () => string;

method readUint8

readUint8: () => number;

method readUnsignedVarint32

readUnsignedVarint32: () => number;

method readUnsignedVarint32String

readUnsignedVarint32String: () => number;

method readUnsignedVarint64

readUnsignedVarint64: () => number;

method readUnsignedVarint64String

readUnsignedVarint64String: () => number;

method readVarintHash64

readVarintHash64: () => string;

method readZigzagVarint32

readZigzagVarint32: () => number;

method readZigzagVarint64

readZigzagVarint64: () => number;

method readZigzagVarint64String

readZigzagVarint64String: () => number;

method reset

reset: () => void;

method setBlock

setBlock: (data: ByteSource, start?: number, length?: number) => void;

method setCursor

setCursor: (cursor: number) => void;

method setEnd

setEnd: (end: number) => void;

method skipVarint

skipVarint: () => void;

method unskipVarint

unskipVarint: (value: number) => void;

class BinaryEncoder

class BinaryEncoder {}

constructor

constructor();

method end

end: () => number[];

method length

length: () => number;

method writeBool

writeBool: (value: boolean) => void;

method writeBytes

writeBytes: (bytes: Uint8Array) => void;

method writeDouble

writeDouble: (value: number) => void;

method writeEnum

writeEnum: (value: number) => void;

method writeFixedHash64

writeFixedHash64: (hash: string) => void;

method writeFloat

writeFloat: (value: number) => void;

method writeInt16

writeInt16: (value: number) => void;

method writeInt32

writeInt32: (value: number) => void;

method writeInt64

writeInt64: (value: number) => void;

method writeInt64String

writeInt64String: (value: string) => void;

method writeInt8

writeInt8: (value: number) => void;

method writeSignedVarint32

writeSignedVarint32: (value: number) => void;

method writeSignedVarint64

writeSignedVarint64: (value: number) => void;

method writeSplitFixed64

writeSplitFixed64: (lowBits: number, highBits: number) => void;

method writeSplitVarint64

writeSplitVarint64: (lowBits: number, highBits: number) => void;

method writeString

writeString: (value: string) => number;

method writeUint16

writeUint16: (value: number) => void;

method writeUint32

writeUint32: (value: number) => void;

method writeUint64

writeUint64: (value: number) => void;

method writeUint8

writeUint8: (value: number) => void;

method writeUnsignedVarint32

writeUnsignedVarint32: (value: number) => void;

method writeUnsignedVarint64

writeUnsignedVarint64: (value: number) => void;

method writeVarintHash64

writeVarintHash64: (hash: string) => void;

method writeZigzagVarint32

writeZigzagVarint32: (value: number) => void;

method writeZigzagVarint64

writeZigzagVarint64: (value: number) => void;

method writeZigzagVarint64String

writeZigzagVarint64String: (value: string) => void;

class BinaryIterator

class BinaryIterator {}

constructor

constructor(
    decoder?: BinaryDecoder,
    next?: () => number | boolean | string | null,
    elements?: (string | number | boolean)[]
);

method alloc

static alloc: (
    decoder?: BinaryDecoder,
    next?: () => number | boolean | string | null,
    elements?: Array<number | boolean | string>
) => BinaryIterator;

method atEnd

atEnd: () => boolean;

method clear

clear: () => void;

method free

free: () => void;

method get

get: () => ScalarFieldType | null;

method next

next: () => ScalarFieldType | null;

class BinaryReader

class BinaryReader {}

constructor

constructor(bytes?: ByteSource, start?: number, length?: number);

property readMessage

readMessage: BinaryRead;

method advance

advance: (count: number) => void;

method alloc

static alloc: (
    bytes?: ByteSource,
    start?: number,
    length?: number
) => BinaryReader;

method free

free: () => void;

method getBuffer

getBuffer: () => Uint8Array;

method getCursor

getCursor: () => number;

method getError

getError: () => boolean;

method getFieldCursor

getFieldCursor: () => number;

method getFieldDecoder

getFieldDecoder: () => BinaryDecoder;

method getFieldNumber

getFieldNumber: () => number;

method getWireType

getWireType: () => BinaryConstants.WireType;

method isDelimited

isDelimited: () => boolean;

method isEndGroup

isEndGroup: () => boolean;

method nextField

nextField: () => boolean;

method readAny

readAny: (fieldType: BinaryConstants.FieldType) => AnyFieldType;

method readBool

readBool: () => boolean;

method readBytes

readBytes: () => Uint8Array;

method readDouble

readDouble: () => number;

method readEnum

readEnum: () => number;

method readFixed32

readFixed32: () => number;

method readFixed64

readFixed64: () => number;

method readFixed64String

readFixed64String: () => string;

method readFixedHash64

readFixedHash64: () => string;

method readFloat

readFloat: () => number;

method readGroup

readGroup: (field: number, message: Message, reader: BinaryReadReader) => void;

method readInt32

readInt32: () => number;

method readInt32String

readInt32String: () => string;

method readInt64

readInt64: () => number;

method readInt64String

readInt64String: () => string;

method readPackedBool

readPackedBool: () => boolean[];

method readPackedDouble

readPackedDouble: () => number[];

method readPackedEnum

readPackedEnum: () => number[];

method readPackedFixed32

readPackedFixed32: () => number[];

method readPackedFixed64

readPackedFixed64: () => number[];

method readPackedFixed64String

readPackedFixed64String: () => string[];

method readPackedFixedHash64

readPackedFixedHash64: () => string[];

method readPackedFloat

readPackedFloat: () => number[];

method readPackedInt32

readPackedInt32: () => number[];

method readPackedInt32String

readPackedInt32String: () => string[];

method readPackedInt64

readPackedInt64: () => number[];

method readPackedInt64String

readPackedInt64String: () => string[];

method readPackedSfixed32

readPackedSfixed32: () => number[];

method readPackedSfixed64

readPackedSfixed64: () => number[];

method readPackedSfixed64String

readPackedSfixed64String: () => string[];

method readPackedSint32

readPackedSint32: () => number[];

method readPackedSint64

readPackedSint64: () => number[];

method readPackedSint64String

readPackedSint64String: () => string[];

method readPackedUint32

readPackedUint32: () => number[];

method readPackedUint32String

readPackedUint32String: () => string[];

method readPackedUint64

readPackedUint64: () => number[];

method readPackedUint64String

readPackedUint64String: () => string[];

method readPackedVarintHash64

readPackedVarintHash64: () => string[];

method readSfixed32

readSfixed32: () => number;

method readSfixed32String

readSfixed32String: () => string;

method readSfixed64

readSfixed64: () => number;

method readSfixed64String

readSfixed64String: () => string;

method readSint32

readSint32: () => number;

method readSint64

readSint64: () => number;

method readSint64String

readSint64String: () => string;

method readString

readString: () => string;

method readUint32

readUint32: () => number;

method readUint32String

readUint32String: () => string;

method readUint64

readUint64: () => number;

method readUint64String

readUint64String: () => string;

method readVarintHash64

readVarintHash64: () => string;

method registerReadCallback

registerReadCallback: (
    callbackName: string,
    callback: (binaryReader: BinaryReader) => any
) => void;

method reset

reset: () => void;

method runReadCallback

runReadCallback: (callbackName: string) => any;

method setBlock

setBlock: (bytes?: ByteSource, start?: number, length?: number) => void;

method skipDelimitedField

skipDelimitedField: () => void;

method skipField

skipField: () => void;

method skipFixed32Field

skipFixed32Field: () => void;

method skipFixed64Field

skipFixed64Field: () => void;

method skipGroup

skipGroup: () => void;

method skipMatchingFields

skipMatchingFields: () => void;

method skipVarintField

skipVarintField: () => void;

method unskipHeader

unskipHeader: () => void;

class BinaryWriter

class BinaryWriter {}

constructor

constructor();

property writeMessage

writeMessage: BinaryWrite;

method beginSubMessage

beginSubMessage: (field: number) => void;

method endSubMessage

endSubMessage: (field: number) => void;

method getResultBase64String

getResultBase64String: () => string;

method getResultBuffer

getResultBuffer: () => Uint8Array;

method maybeWriteSerializedMessage

maybeWriteSerializedMessage: (
    bytes?: Uint8Array,
    start?: number,
    end?: number
) => void;

method reset

reset: () => void;

method writeAny

writeAny: (
    fieldType: BinaryConstants.FieldType,
    field: number,
    value: AnyFieldType
) => void;

method writeBool

writeBool: (field: number, value?: boolean) => void;

method writeBytes

writeBytes: (field: number, value?: ByteSource) => void;

method writeDouble

writeDouble: (field: number, value?: number) => void;

method writeEnum

writeEnum: (field: number, value?: number) => void;

method writeFixed32

writeFixed32: (field: number, value?: number) => void;

method writeFixed64

writeFixed64: (field: number, value?: number) => void;

method writeFixed64String

writeFixed64String: (field: number, value?: string) => void;

method writeFixedHash64

writeFixedHash64: (field: number, value?: string) => void;

method writeFloat

writeFloat: (field: number, value?: number) => void;

method writeGroup

writeGroup: (
    field: number,
    value: any,
    writeCallback: BinaryWriteCallback
) => void;

method writeInt32

writeInt32: (field: number, value?: number) => void;

method writeInt32String

writeInt32String: (field: number, value?: string) => void;

method writeInt64

writeInt64: (field: number, value?: number) => void;

method writeInt64String

writeInt64String: (field: number, value?: string) => void;

method writePackedBool

writePackedBool: (field: number, value?: boolean[]) => void;

method writePackedDouble

writePackedDouble: (field: number, value?: number[]) => void;

method writePackedEnum

writePackedEnum: (field: number, value?: number[]) => void;

method writePackedFixed32

writePackedFixed32: (field: number, value?: number[]) => void;

method writePackedFixed64

writePackedFixed64: (field: number, value?: number[]) => void;

method writePackedFixed64String

writePackedFixed64String: (field: number, value?: string[]) => void;

method writePackedFixedHash64

writePackedFixedHash64: (field: number, value?: string[]) => void;

method writePackedFloat

writePackedFloat: (field: number, value?: number[]) => void;

method writePackedInt32

writePackedInt32: (field: number, value?: number[]) => void;

method writePackedInt32String

writePackedInt32String: (field: number, value?: string[]) => void;

method writePackedInt64

writePackedInt64: (field: number, value?: number[]) => void;

method writePackedInt64String

writePackedInt64String: (field: number, value?: string[]) => void;

method writePackedSfixed32

writePackedSfixed32: (field: number, value?: number[]) => void;

method writePackedSfixed64

writePackedSfixed64: (field: number, value?: number[]) => void;

method writePackedSfixed64String

writePackedSfixed64String: (field: number, value?: string[]) => void;

method writePackedSint32

writePackedSint32: (field: number, value?: number[]) => void;

method writePackedSint64

writePackedSint64: (field: number, value?: number[]) => void;

method writePackedSint64String

writePackedSint64String: (field: number, value?: string[]) => void;

method writePackedUint32

writePackedUint32: (field: number, value?: number[]) => void;

method writePackedUint32String

writePackedUint32String: (field: number, value?: string[]) => void;

method writePackedUint64

writePackedUint64: (field: number, value?: number[]) => void;

method writePackedUint64String

writePackedUint64String: (field: number, value?: string[]) => void;

method writePackedVarintHash64

writePackedVarintHash64: (field: number, value?: string[]) => void;

method writeRepeatedBool

writeRepeatedBool: (field: number, value?: boolean[]) => void;

method writeRepeatedBytes

writeRepeatedBytes: (field: number, value?: ByteSource[]) => void;

method writeRepeatedDouble

writeRepeatedDouble: (field: number, value?: number[]) => void;

method writeRepeatedEnum

writeRepeatedEnum: (field: number, value?: number[]) => void;

method writeRepeatedFixed32

writeRepeatedFixed32: (field: number, value?: number[]) => void;

method writeRepeatedFixed64

writeRepeatedFixed64: (field: number, value?: number[]) => void;

method writeRepeatedFixed64String

writeRepeatedFixed64String: (field: number, value?: string[]) => void;

method writeRepeatedFixedHash64

writeRepeatedFixedHash64: (field: number, value?: string[]) => void;

method writeRepeatedFloat

writeRepeatedFloat: (field: number, value?: number[]) => void;

method writeRepeatedGroup

writeRepeatedGroup: (
    field: number,
    value: Message[],
    writerCallback: BinaryWriteCallback
) => void;

method writeRepeatedInt32

writeRepeatedInt32: (field: number, value?: number[]) => void;

method writeRepeatedInt32String

writeRepeatedInt32String: (field: number, value?: string[]) => void;

method writeRepeatedInt64

writeRepeatedInt64: (field: number, value?: number[]) => void;

method writeRepeatedInt64String

writeRepeatedInt64String: (field: number, value?: string[]) => void;

method writeRepeatedMessage

writeRepeatedMessage: (
    field: number,
    value: Message[],
    writerCallback: BinaryWriteCallback
) => void;

method writeRepeatedSfixed32

writeRepeatedSfixed32: (field: number, value?: number[]) => void;

method writeRepeatedSfixed64

writeRepeatedSfixed64: (field: number, value?: number[]) => void;

method writeRepeatedSfixed64String

writeRepeatedSfixed64String: (field: number, value?: string[]) => void;

method writeRepeatedSint32

writeRepeatedSint32: (field: number, value?: number[]) => void;

method writeRepeatedSint64

writeRepeatedSint64: (field: number, value?: number[]) => void;

method writeRepeatedSint64String

writeRepeatedSint64String: (field: number, value?: string[]) => void;

method writeRepeatedString

writeRepeatedString: (field: number, value?: string[]) => void;

method writeRepeatedUint32

writeRepeatedUint32: (field: number, value?: number[]) => void;

method writeRepeatedUint32String

writeRepeatedUint32String: (field: number, value?: string[]) => void;

method writeRepeatedUint64

writeRepeatedUint64: (field: number, value?: number[]) => void;

method writeRepeatedUint64String

writeRepeatedUint64String: (field: number, value?: string[]) => void;

method writeRepeatedVarintHash64

writeRepeatedVarintHash64: (field: number, value?: string[]) => void;

method writeSerializedMessage

writeSerializedMessage: (bytes: Uint8Array, start: number, end: number) => void;

method writeSfixed32

writeSfixed32: (field: number, value?: number) => void;

method writeSfixed64

writeSfixed64: (field: number, value?: number) => void;

method writeSfixed64String

writeSfixed64String: (field: number, value?: string) => void;

method writeSint32

writeSint32: (field: number, value?: number) => void;

method writeSint64

writeSint64: (field: number, value?: number) => void;

method writeSint64String

writeSint64String: (field: number, value?: string) => void;

method writeString

writeString: (field: number, value?: string) => void;

method writeUint32

writeUint32: (field: number, value?: number) => void;

method writeUint32String

writeUint32String: (field: number, value?: string) => void;

method writeUint64

writeUint64: (field: number, value?: number) => void;

method writeUint64String

writeUint64String: (field: number, value?: string) => void;

method writeVarintHash64

writeVarintHash64: (field: number, value?: string) => void;

class ExtensionFieldBinaryInfo

class ExtensionFieldBinaryInfo<T> {}

constructor

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
);

property binaryReaderFn

binaryReaderFn: BinaryRead;

property binaryWriterFn

binaryWriterFn: BinaryWrite;

property fieldInfo

fieldInfo: ExtensionFieldInfo<T>;

property opt_binaryMessageDeserializeFn

opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message;

property opt_binaryMessageSerializeFn

opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void;

property opt_isPacked

opt_isPacked: boolean;

class ExtensionFieldInfo

class ExtensionFieldInfo<T> {}

constructor

constructor(
    fieldIndex: number,
    fieldName: { [key: string]: number },
    ctor: typeof Message,
    toObjectFn: Message.StaticToObject,
    isRepeated: number
);

property ctor

ctor: typeof Message;

property fieldIndex

fieldIndex: number;

property fieldName

fieldName: number;

property isRepeated

isRepeated: number;

property toObjectFn

toObjectFn: Message.StaticToObject;

method isMessageType

isMessageType: () => boolean;

class Map

class Map<K, V> {}

constructor

constructor(arr: [K, V][], valueCtor?: new (init: any) => V);

method clear

clear: () => void;

method del

del: (key: K) => boolean;

method deserializeBinary

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;

method entries

entries: () => Map.Iterator<[K, V]>;

method forEach

forEach: (callback: (entry: V, key: K) => void, thisArg?: {}) => void;

method fromObject

static fromObject: <TK, TV>(
    entries: Array<[TK, TV]>,
    valueCtor: any,
    valueFromObject: any
) => Map<TK, TV>;

method get

get: (key: K) => V | undefined;

method getEntryList

getEntryList: () => Array<[K, V]>;

method getLength

getLength: () => number;

method has

has: (key: K) => boolean;

method keys

keys: () => Map.Iterator<K>;

method serializeBinary

serializeBinary: (
    fieldNumber: number,
    writer: BinaryWriter,
    keyWriterFn: (field: number, key: K) => void,
    valueWriterFn: (
        field: number,
        value: V,
        writerCallback: BinaryWriteCallback
    ) => void,
    writeCallback?: BinaryWriteCallback
) => void;

method set

set: (key: K, value: V) => this;

method toArray

toArray: () => Array<[K, V]>;

method toObject

toObject: {
    (includeInstance?: boolean): Array<[K, V]>;
    <VO>(
        includeInstance: boolean,
        valueToObject: (includeInstance: boolean, valueWrapper: V) => VO
    ): [K, VO][];
};

method values

values: () => Map.Iterator<V>;

class Message

abstract class Message {}

property extensions

static extensions: { [key: number]: ExtensionFieldInfo<Message> };

property extensionsBinary

static extensionsBinary: { [key: number]: ExtensionFieldBinaryInfo<Message> };

method addToRepeatedField

static addToRepeatedField: (
    msg: Message,
    fieldNumber: number,
    value: any,
    index?: number
) => void;

method addToRepeatedWrapperField

static addToRepeatedWrapperField: <T extends Message>(
    msg: Message,
    fieldNumber: number,
    value: T | undefined,
    ctor: { new (): T },
    index?: number
) => T;

method bytesAsB64

static bytesAsB64: (bytes: Uint8Array) => string;

method bytesAsU8

static bytesAsU8: (str: string) => Uint8Array;

method bytesListAsB64

static bytesListAsB64: (bytesList: Uint8Array[]) => string[];

method bytesListAsU8

static bytesListAsU8: (strList: string[]) => Uint8Array[];

method clone

static clone: <T extends Message>(msg: T) => T;

method cloneMessage

static cloneMessage: <T extends Message>(msg: T) => T;

method compareExtensions

static compareExtensions: (extension1: {}, extension2: {}) => boolean;

method compareFields

static compareFields: (field1: any, field2: any) => boolean;

method computeOneofCase

static computeOneofCase: (msg: Message, oneof: number[]) => number;

method copyInto

static copyInto: (fromMessage: Message, toMessage: Message) => void;

method deserializeBinary

static deserializeBinary: (bytes: Uint8Array) => Message;

method deserializeBinaryFromReader

static deserializeBinaryFromReader: (
    message: Message,
    reader: BinaryReader
) => Message;

method difference

static difference: <T extends Message>(m1: T, m2: T) => T;

method equals

static equals: (m1: Message, m2: Message) => boolean;

method getExtension

getExtension: <T>(fieldInfo: ExtensionFieldInfo<T>) => T;

method getField

static getField: (msg: Message, fieldNumber: number) => FieldValue | null;

method getFieldWithDefault

static getFieldWithDefault: <T>(
    msg: Message,
    fieldNumber: number,
    defaultValue: T
) => T;

method getJsPbMessageId

getJsPbMessageId: () => string | undefined;

method getMapField

static getMapField: (
    msg: Message,
    fieldNumber: number,
    noLazyCreate: boolean,
    valueCtor?: typeof Message
) => Map<any, any>;

method getOptionalFloatingPointField

static getOptionalFloatingPointField: (
    msg: Message,
    fieldNumber: number
) => number | undefined;

method getRepeatedFloatingPointField

static getRepeatedFloatingPointField: (
    msg: Message,
    fieldNumber: number
) => number[];

method getRepeatedWrapperField

static getRepeatedWrapperField: <T extends Message>(
    msg: Message,
    ctor: { new (): T },
    fieldNumber: number
) => T[];

method getWrapperField

static getWrapperField: <T extends Message>(
    msg: Message,
    ctor: { new (): T },
    fieldNumber: number,
    required?: number
) => T;

method initialize

static initialize: (
    msg: Message,
    data: Message.MessageArray,
    messageId: string | number,
    suggestedPivot: number,
    repeatedFields?: number[] | null,
    oneofFields?: number[][] | null
) => void;

method readBinaryExtension

readBinaryExtension: (
    proto: Message,
    reader: BinaryReader,
    extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
    setExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>, val: T) => void
) => void;

method registerMessageType

static registerMessageType: (id: number, constructor: typeof Message) => void;

method serializeBinary

abstract serializeBinary: () => Uint8Array;

method serializeBinaryExtensions

serializeBinaryExtensions: (
    proto: Message,
    writer: BinaryWriter,
    extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
    getExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>) => T
) => void;

method serializeBinaryToWriter

static serializeBinaryToWriter: (message: Message, writer: BinaryWriter) => void;

method setExtension

setExtension: <T>(fieldInfo: ExtensionFieldInfo<T>, value: T) => void;

method setField

static setField: (msg: Message, fieldNumber: number, value: FieldValue) => void;

method setOneofField

static setOneofField: (
    msg: Message,
    fieldNumber: number,
    oneof: number[],
    value: FieldValue
) => void;

method setOneofWrapperField

static setOneofWrapperField: (
    msg: Message,
    fieldNumber: number,
    oneof: number[],
    value: any
) => void;

method setRepeatedWrapperField

static setRepeatedWrapperField: <T extends Message>(
    msg: Message,
    fieldNumber: number,
    value?: T[]
) => void;

method setWrapperField

static setWrapperField: <T extends Message>(
    msg: Message,
    fieldNumber: number,
    value?: T | Map<any, any>
) => void;

method toArray

toArray: () => Message.MessageArray;

method toMap

static toMap: (
    field: any[],
    mapKeyGetterFn: (field: any) => string,
    toObjectFn?: Message.StaticToObject,
    includeInstance?: boolean
) => void;

method toObject

static toObject: (includeInstance: boolean, msg: Message) => {};

method toObjectExtension

static toObjectExtension: (
    msg: Message,
    obj: {},
    extensions: { [key: number]: ExtensionFieldInfo<Message> },
    getExtensionFn: (fieldInfo: ExtensionFieldInfo<Message>) => Message,
    includeInstance?: boolean
) => void;

method toObjectList

static toObjectList: <T extends Message>(
    field: T[],
    toObjectFn: (includeInstance: boolean, data: T) => {},
    includeInstance?: boolean
) => Array<{}>;

method toString

toString: () => string;

Interfaces

interface FieldValueArray

interface FieldValueArray extends Array<FieldValue> {}

Type Aliases

type AnyFieldType

type AnyFieldType = ScalarFieldType | RepeatedFieldType | Uint8Array;

type BinaryRead

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

type BinaryReadCallback

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

type BinaryReadReader

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

type BinaryWrite

type BinaryWrite = (
    fieldNumber: number,
    value: any,
    writerCallback: BinaryWriteCallback
) => void;

type BinaryWriteCallback

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

type ByteSource

type ByteSource = ArrayBuffer | Uint8Array | number[] | string;

type FieldValue

type FieldValue =
    | string
    | number
    | boolean
    | Uint8Array
    | FieldValueArray
    | undefined;

type RepeatedFieldType

type RepeatedFieldType = ScalarFieldType[] | Uint8Array[];

type ScalarFieldType

type ScalarFieldType = boolean | number | string;

Namespaces

namespace arith

namespace arith {}

class Int64

class Int64 {}

constructor

constructor(lo: number, hi: number);

property hi

hi: number;

property lo

lo: number;

method add

add: (other: Int64) => Int64;

method clone

clone: () => Int64;

method fromString

static fromString: (str: string) => Int64;

method sub

sub: (other: Int64) => Int64;

method toString

toString: () => string;

class UInt64

class UInt64 {}

constructor

constructor(lo: number, hi: number);

property hi

hi: number;

property lo

lo: number;

method add

add: (other: UInt64) => UInt64;

method clone

clone: () => UInt64;

method cmp

cmp: (other: UInt64) => number;

method div

div: (divisor: number) => [UInt64, UInt64];

method fromString

static fromString: (str: string) => UInt64;

method leftShift

leftShift: () => UInt64;

method lsb

lsb: () => boolean;

method msb

msb: () => boolean;

method mul

mul: (a: number) => UInt64;

method mul32x32

static mul32x32: (a: number, b: number) => UInt64;

method rightShift

rightShift: () => UInt64;

method sub

sub: (other: UInt64) => UInt64;

method toString

toString: () => string;

method zero

zero: () => boolean;

namespace BinaryConstants

namespace BinaryConstants {}

variable FLOAT32_EPS

const FLOAT32_EPS: number;

variable FLOAT32_MAX

const FLOAT32_MAX: number;

variable FLOAT32_MIN

const FLOAT32_MIN: number;

variable FLOAT64_EPS

const FLOAT64_EPS: number;

variable FLOAT64_MAX

const FLOAT64_MAX: number;

variable FLOAT64_MIN

const FLOAT64_MIN: number;

variable INVALID_FIELD_NUMBER

const INVALID_FIELD_NUMBER: number;

variable TWO_TO_20

const TWO_TO_20: number;

variable TWO_TO_23

const TWO_TO_23: number;

variable TWO_TO_31

const TWO_TO_31: number;

variable TWO_TO_32

const TWO_TO_32: number;

variable TWO_TO_52

const TWO_TO_52: number;

variable TWO_TO_63

const TWO_TO_63: number;

variable TWO_TO_64

const TWO_TO_64: number;

variable ZERO_HASH

const ZERO_HASH: string;

function FieldTypeToWireType

FieldTypeToWireType: (fieldType: FieldType) => WireType;

enum FieldType

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,
}

member BOOL

BOOL = 8

member BYTES

BYTES = 12

member DOUBLE

DOUBLE = 1

member ENUM

ENUM = 14

member FHASH64

FHASH64 = 30

member FIXED32

FIXED32 = 7

member FIXED64

FIXED64 = 6

member FLOAT

FLOAT = 2

member GROUP

GROUP = 10

member INT32

INT32 = 5

member INT64

INT64 = 3

member INVALID

INVALID = -1

member MESSAGE

MESSAGE = 11

member SFIXED32

SFIXED32 = 15

member SFIXED64

SFIXED64 = 16

member SINT32

SINT32 = 17

member SINT64

SINT64 = 18

member STRING

STRING = 9

member UINT32

UINT32 = 13

member UINT64

UINT64 = 4

member VHASH64

VHASH64 = 31

enum WireType

enum WireType {
    INVALID = -1,
    VARINT = 0,
    FIXED64 = 1,
    DELIMITED = 2,
    START_GROUP = 3,
    END_GROUP = 4,
    FIXED32 = 5,
}

member DELIMITED

DELIMITED = 2

member END_GROUP

END_GROUP = 4

member FIXED32

FIXED32 = 5

member FIXED64

FIXED64 = 1

member INVALID

INVALID = -1

member START_GROUP

START_GROUP = 3

member VARINT

VARINT = 0

namespace Map

namespace Map {}

interface Iterator

interface Iterator<T> {}

method [Symbol.iterator]

[Symbol.iterator]: () => Iterator<T>;

method next

next: () => IteratorResult<T>;

interface IteratorResult

interface IteratorResult<T> {}

property done

done: boolean;

property value

value: T;

namespace Message

namespace Message {}

type MessageArray

type MessageArray = any[];

type StaticToObject

type StaticToObject = (includeInstance: boolean, msg: Message) => {};

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/google-protobuf.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/google-protobuf)

HTML

<a href="https://www.jsdocs.io/package/@types/google-protobuf"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 6 months ago.
Package analyzed in 5884 ms.
Missing or incorrect documentation? Open an issue for this package.