1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | type ByteSource = ArrayBuffer | Uint8Array | number[] | string;
|
8 | type ScalarFieldType = boolean | number | string;
|
9 | type RepeatedFieldType = ScalarFieldType[] | Uint8Array[];
|
10 | type AnyFieldType = ScalarFieldType | RepeatedFieldType | Uint8Array;
|
11 | type FieldValue = string | number | boolean | Uint8Array | FieldValueArray | undefined;
|
12 | interface FieldValueArray extends Array<FieldValue> {}
|
13 |
|
14 | export abstract class Message {
|
15 | getJsPbMessageId(): (string | undefined);
|
16 | static initialize(
|
17 | msg: Message,
|
18 | data: Message.MessageArray,
|
19 | messageId: (string | number),
|
20 | suggestedPivot: number,
|
21 | repeatedFields?: number[] | null,
|
22 | oneofFields?: number[][] | null): void;
|
23 | static toObjectList<T extends Message>(
|
24 | field: T[],
|
25 | toObjectFn: (includeInstance: boolean, data: T) => {},
|
26 | includeInstance?: boolean): Array<{}>;
|
27 | static toObjectExtension(
|
28 | msg: Message,
|
29 | obj: {},
|
30 | extensions: {[key: number]: ExtensionFieldInfo<Message>},
|
31 | getExtensionFn: (fieldInfo: ExtensionFieldInfo<Message>) => Message,
|
32 | includeInstance?: boolean): void;
|
33 | serializeBinaryExtensions(
|
34 | proto: Message,
|
35 | writer: BinaryWriter,
|
36 | extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
|
37 | getExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>) => T): void
|
38 | readBinaryExtension(
|
39 | proto: Message,
|
40 | reader: BinaryReader,
|
41 | extensions: {[key: number]: ExtensionFieldBinaryInfo<Message>},
|
42 | setExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>,
|
43 | val: T) => void): void
|
44 | static getField(msg: Message, fieldNumber: number): FieldValue|null;
|
45 | static getOptionalFloatingPointField(msg: Message, fieldNumber: number): number | undefined;
|
46 | static getRepeatedFloatingPointField(msg: Message, fieldNumber: number): number[];
|
47 | static bytesAsB64(bytes: Uint8Array): string;
|
48 | static bytesAsU8(str: string): Uint8Array;
|
49 | static bytesListAsB64(bytesList: Uint8Array[]): string[];
|
50 | static bytesListAsU8(strList: string[]): Uint8Array[];
|
51 | static getFieldWithDefault<T>(msg: Message, fieldNumber: number, defaultValue: T): T;
|
52 | static getMapField(
|
53 | msg: Message,
|
54 | fieldNumber: number,
|
55 | noLazyCreate: boolean,
|
56 | valueCtor?: typeof Message): Map<any, any>;
|
57 | static setField(
|
58 | msg: Message,
|
59 | fieldNumber: number,
|
60 | value: FieldValue): void;
|
61 | static addToRepeatedField(
|
62 | msg: Message,
|
63 | fieldNumber: number,
|
64 | value: any,
|
65 | index?: number): void;
|
66 | static setOneofField(
|
67 | msg: Message,
|
68 | fieldNumber: number,
|
69 | oneof: number[],
|
70 | value: FieldValue): void;
|
71 | static computeOneofCase(msg: Message, oneof: number[]): number;
|
72 | static getWrapperField<T extends Message>(
|
73 | msg: Message,
|
74 | ctor: { new(): T },
|
75 | fieldNumber: number,
|
76 | required?: number): T;
|
77 | static getRepeatedWrapperField<T extends Message>(
|
78 | msg: Message,
|
79 | ctor: { new(): T },
|
80 | fieldNumber: number): T[];
|
81 | static setWrapperField<T extends Message>(
|
82 | msg: Message,
|
83 | fieldNumber: number,
|
84 | value?: (T|Map<any, any>)): void;
|
85 | static setOneofWrapperField(
|
86 | msg: Message,
|
87 | fieldNumber: number,
|
88 | oneof: number[],
|
89 | value: any): void;
|
90 | static setRepeatedWrapperField<T extends Message>(
|
91 | msg: Message,
|
92 | fieldNumber: number,
|
93 | value?: T[]): void;
|
94 | static addToRepeatedWrapperField<T extends Message>(
|
95 | msg: Message,
|
96 | fieldNumber: number,
|
97 | value: T | undefined,
|
98 | ctor: { new(): T },
|
99 | index?: number): T;
|
100 | static toMap(
|
101 | field: any[],
|
102 | mapKeyGetterFn: (field: any) => string,
|
103 | toObjectFn?: Message.StaticToObject,
|
104 | includeInstance?: boolean): void;
|
105 | toArray(): Message.MessageArray;
|
106 | toString(): string;
|
107 | getExtension<T>(fieldInfo: ExtensionFieldInfo<T>): T;
|
108 | setExtension<T>(fieldInfo: ExtensionFieldInfo<T>, value: T): void;
|
109 | static difference<T extends Message>(m1: T, m2: T): T;
|
110 | static equals(m1: Message, m2: Message): boolean;
|
111 | static compareExtensions(extension1: {}, extension2: {}): boolean;
|
112 | static compareFields(field1: any, field2: any): boolean;
|
113 | cloneMessage(): this;
|
114 | clone(): this;
|
115 | static clone<T extends Message>(msg: T): T;
|
116 | static cloneMessage<T extends Message>(msg: T): T;
|
117 | static copyInto(fromMessage: Message, toMessage: Message): void;
|
118 | static registerMessageType(id: number, constructor: typeof Message): void;
|
119 |
|
120 | abstract serializeBinary(): Uint8Array;
|
121 | abstract toObject(includeInstance?: boolean): {};
|
122 |
|
123 |
|
124 |
|
125 | static deserializeBinary(bytes: Uint8Array): Message;
|
126 | static deserializeBinaryFromReader(message: Message, reader: BinaryReader): Message;
|
127 | static serializeBinaryToWriter(message: Message, writer: BinaryWriter): void;
|
128 | static toObject(includeInstance: boolean, msg: Message): {};
|
129 | static extensions: { [key: number]: ExtensionFieldInfo<Message> };
|
130 | static extensionsBinary: { [key: number]: ExtensionFieldBinaryInfo<Message> };
|
131 | }
|
132 |
|
133 | export namespace Message {
|
134 | type MessageArray = any[];
|
135 | type StaticToObject = (includeInstance: boolean, msg: Message) => {};
|
136 | }
|
137 |
|
138 | export class ExtensionFieldInfo<T> {
|
139 | fieldIndex: number;
|
140 | fieldName: number;
|
141 | ctor: typeof Message;
|
142 | toObjectFn: Message.StaticToObject;
|
143 | isRepeated: number;
|
144 | constructor(
|
145 | fieldIndex: number,
|
146 | fieldName: {[key: string]: number},
|
147 | ctor: typeof Message,
|
148 | toObjectFn: Message.StaticToObject,
|
149 | isRepeated: number);
|
150 | isMessageType(): boolean;
|
151 | }
|
152 |
|
153 | export class ExtensionFieldBinaryInfo<T> {
|
154 | fieldInfo: ExtensionFieldInfo<T>;
|
155 | binaryReaderFn: BinaryRead;
|
156 | binaryWriterFn: BinaryWrite;
|
157 | opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void;
|
158 | opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message;
|
159 | opt_isPacked: boolean;
|
160 | constructor(
|
161 | fieldInfo: ExtensionFieldInfo<T>,
|
162 | binaryReaderFn: BinaryRead,
|
163 | binaryWriterFn: BinaryWrite,
|
164 | opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void,
|
165 | opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message,
|
166 | opt_isPacked: boolean);
|
167 | }
|
168 |
|
169 | export class Map<K, V> {
|
170 | constructor(
|
171 | arr: Array<[K, V]>,
|
172 | valueCtor?: {new(init: any): V});
|
173 | toArray(): Array<[K, V]>;
|
174 | toObject(includeInstance?: boolean): Array<[K, V]>;
|
175 | toObject<VO>(
|
176 | includeInstance: boolean,
|
177 | valueToObject: (includeInstance: boolean, valueWrapper: V) => VO): Array<[K, VO]>;
|
178 | static fromObject<TK, TV>(
|
179 | entries: Array<[TK, TV]>,
|
180 | valueCtor: any,
|
181 | valueFromObject: any): Map<TK, TV>;
|
182 | getLength(): number;
|
183 | clear(): void;
|
184 | del(key: K): boolean;
|
185 | getEntryList(): Array<[K, V]>;
|
186 | entries(): Map.Iterator<[K, V]>;
|
187 | keys(): Map.Iterator<K>;
|
188 | values(): Map.Iterator<V>;
|
189 | forEach(
|
190 | callback: (entry: V, key: K) => void,
|
191 | thisArg?: {}): void;
|
192 | set(key: K, value: V): this;
|
193 | get(key: K): (V | undefined);
|
194 | has(key: K): boolean;
|
195 | serializeBinary(
|
196 | fieldNumber: number,
|
197 | writer: BinaryWriter,
|
198 | keyWriterFn: (field: number, key: K) => void,
|
199 | valueWriterFn: (field: number, value: V, writerCallback: BinaryWriteCallback) => void,
|
200 | writeCallback?: BinaryWriteCallback
|
201 | ): void;
|
202 | static deserializeBinary<K, V>(
|
203 | map: Map<K, V>,
|
204 | reader: BinaryReader,
|
205 | keyReaderFn: (reader: BinaryReader) => K,
|
206 | valueReaderFn: (reader: BinaryReader, value: any, readerCallback: BinaryReadCallback) => V,
|
207 | readCallback?: BinaryReadCallback,
|
208 | defaultKey?: K,
|
209 | defaultValue?: V
|
210 | ): void;
|
211 | }
|
212 |
|
213 | export namespace Map {
|
214 |
|
215 | interface Iterator<T> {
|
216 | [Symbol.iterator](): Iterator<T>;
|
217 | next(): IteratorResult<T>;
|
218 | }
|
219 | interface IteratorResult<T> {
|
220 | done: boolean;
|
221 | value: T;
|
222 | }
|
223 | }
|
224 |
|
225 | type BinaryReadReader = (msg: any, binaryReader: BinaryReader) => void;
|
226 |
|
227 | type BinaryRead = (msg: any, reader: BinaryReadReader) => any;
|
228 |
|
229 | type BinaryReadCallback = (value: any, binaryReader: BinaryReader) => void;
|
230 |
|
231 | type BinaryWriteCallback = (value: any, binaryWriter: BinaryWriter) => void;
|
232 |
|
233 | type BinaryWrite = (fieldNumber: number, value: any, writerCallback: BinaryWriteCallback) => void;
|
234 |
|
235 | export class BinaryReader {
|
236 | constructor(bytes?: ByteSource, start?: number, length?: number);
|
237 | static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
|
238 | alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
|
239 | free(): void;
|
240 | getFieldCursor(): number;
|
241 | getCursor(): number;
|
242 | getBuffer(): Uint8Array;
|
243 | getFieldNumber(): number;
|
244 | getWireType(): BinaryConstants.WireType;
|
245 | isEndGroup(): boolean;
|
246 | getError(): boolean;
|
247 | setBlock(bytes?: ByteSource, start?: number, length?: number): void;
|
248 | reset(): void;
|
249 | advance(count: number): void;
|
250 | nextField(): boolean;
|
251 | unskipHeader(): void;
|
252 | skipMatchingFields(): void;
|
253 | skipVarintField(): void;
|
254 | skipDelimitedField(): void;
|
255 | skipFixed32Field(): void;
|
256 | skipFixed64Field(): void;
|
257 | skipGroup(): void;
|
258 | skipField(): void;
|
259 | registerReadCallback(callbackName: string, callback: (binaryReader: BinaryReader) => any): void;
|
260 | runReadCallback(callbackName: string): any;
|
261 | readAny(fieldType: BinaryConstants.FieldType): AnyFieldType;
|
262 | readMessage: BinaryRead;
|
263 | readGroup(field: number, message: Message, reader: BinaryReadReader): void;
|
264 | getFieldDecoder(): BinaryDecoder;
|
265 | readInt32(): number;
|
266 | readInt32String(): string;
|
267 | readInt64(): number;
|
268 | readInt64String(): string;
|
269 | readUint32(): number;
|
270 | readUint32String(): string;
|
271 | readUint64(): number;
|
272 | readUint64String(): string;
|
273 | readSint32(): number;
|
274 | readSint64(): number;
|
275 | readSint64String(): string;
|
276 | readFixed32(): number;
|
277 | readFixed64(): number;
|
278 | readFixed64String(): string;
|
279 | readSfixed32(): number;
|
280 | readSfixed32String(): string;
|
281 | readSfixed64(): number;
|
282 | readSfixed64String(): string;
|
283 | readFloat(): number;
|
284 | readDouble(): number;
|
285 | readBool(): boolean;
|
286 | readEnum(): number;
|
287 | readString(): string;
|
288 | readBytes(): Uint8Array;
|
289 | readVarintHash64(): string;
|
290 | readFixedHash64(): string;
|
291 | readPackedInt32(): number[];
|
292 | readPackedInt32String(): string[];
|
293 | readPackedInt64(): number[];
|
294 | readPackedInt64String(): string[];
|
295 | readPackedUint32(): number[];
|
296 | readPackedUint32String(): string[];
|
297 | readPackedUint64(): number[];
|
298 | readPackedUint64String(): string[];
|
299 | readPackedSint32(): number[];
|
300 | readPackedSint64(): number[];
|
301 | readPackedSint64String(): string[];
|
302 | readPackedFixed32(): number[];
|
303 | readPackedFixed64(): number[];
|
304 | readPackedFixed64String(): string[];
|
305 | readPackedSfixed32(): number[];
|
306 | readPackedSfixed64(): number[];
|
307 | readPackedSfixed64String(): string[];
|
308 | readPackedFloat(): number[];
|
309 | readPackedDouble(): number[];
|
310 | readPackedBool(): boolean[];
|
311 | readPackedEnum(): number[];
|
312 | readPackedVarintHash64(): string[];
|
313 | readPackedFixedHash64(): string[];
|
314 | }
|
315 |
|
316 | export class BinaryWriter {
|
317 | constructor();
|
318 | writeSerializedMessage(bytes: Uint8Array, start: number, end: number): void;
|
319 | maybeWriteSerializedMessage(bytes?: Uint8Array, start?: number, end?: number): void;
|
320 | reset(): void;
|
321 | getResultBuffer(): Uint8Array;
|
322 | getResultBase64String(): string;
|
323 | beginSubMessage(field: number): void;
|
324 | endSubMessage(field: number): void;
|
325 | writeAny(fieldType: BinaryConstants.FieldType, field: number, value: AnyFieldType): void;
|
326 | writeInt32(field: number, value?: number): void;
|
327 | writeInt32String(field: number, value?: string): void;
|
328 | writeInt64(field: number, value?: number): void;
|
329 | writeInt64String(field: number, value?: string): void;
|
330 | writeUint32(field: number, value?: number): void;
|
331 | writeUint32String(field: number, value?: string): void;
|
332 | writeUint64(field: number, value?: number): void;
|
333 | writeUint64String(field: number, value?: string): void;
|
334 | writeSint32(field: number, value?: number): void;
|
335 | writeSint64(field: number, value?: number): void;
|
336 | writeSint64String(field: number, value?: string): void;
|
337 | writeFixed32(field: number, value?: number): void;
|
338 | writeFixed64(field: number, value?: number): void;
|
339 | writeFixed64String(field: number, value?: string): void;
|
340 | writeSfixed32(field: number, value?: number): void;
|
341 | writeSfixed64(field: number, value?: number): void;
|
342 | writeSfixed64String(field: number, value?: string): void;
|
343 | writeFloat(field: number, value?: number): void;
|
344 | writeDouble(field: number, value?: number): void;
|
345 | writeBool(field: number, value?: boolean): void;
|
346 | writeEnum(field: number, value?: number): void;
|
347 | writeString(field: number, value?: string): void;
|
348 | writeBytes(field: number, value?: ByteSource): void;
|
349 | writeMessage: BinaryWrite;
|
350 | writeGroup(field: number, value: any, writeCallback: BinaryWriteCallback): void;
|
351 | writeFixedHash64(field: number, value?: string): void;
|
352 | writeVarintHash64(field: number, value?: string): void;
|
353 | writeRepeatedInt32(field: number, value?: number[]): void;
|
354 | writeRepeatedInt32String(field: number, value?: string[]): void;
|
355 | writeRepeatedInt64(field: number, value?: number[]): void;
|
356 | writeRepeatedInt64String(field: number, value?: string[]): void;
|
357 | writeRepeatedUint32(field: number, value?: number[]): void;
|
358 | writeRepeatedUint32String(field: number, value?: string[]): void;
|
359 | writeRepeatedUint64(field: number, value?: number[]): void;
|
360 | writeRepeatedUint64String(field: number, value?: string[]): void;
|
361 | writeRepeatedSint32(field: number, value?: number[]): void;
|
362 | writeRepeatedSint64(field: number, value?: number[]): void;
|
363 | writeRepeatedSint64String(field: number, value?: string[]): void;
|
364 | writeRepeatedFixed32(field: number, value?: number[]): void;
|
365 | writeRepeatedFixed64(field: number, value?: number[]): void;
|
366 | writeRepeatedFixed64String(field: number, value?: string[]): void;
|
367 | writeRepeatedSfixed32(field: number, value?: number[]): void;
|
368 | writeRepeatedSfixed64(field: number, value?: number[]): void;
|
369 | writeRepeatedSfixed64String(field: number, value?: string[]): void;
|
370 | writeRepeatedFloat(field: number, value?: number[]): void;
|
371 | writeRepeatedDouble(field: number, value?: number[]): void;
|
372 | writeRepeatedBool(field: number, value?: boolean[]): void;
|
373 | writeRepeatedEnum(field: number, value?: number[]): void;
|
374 | writeRepeatedString(field: number, value?: string[]): void;
|
375 | writeRepeatedBytes(field: number, value?: ByteSource[]): void;
|
376 | writeRepeatedMessage(field: number, value: Message[], writerCallback: BinaryWriteCallback): void;
|
377 | writeRepeatedGroup(field: number, value: Message[], writerCallback: BinaryWriteCallback): void;
|
378 | writeRepeatedFixedHash64(field: number, value?: string[]): void;
|
379 | writeRepeatedVarintHash64(field: number, value?: string[]): void;
|
380 | writePackedInt32(field: number, value?: number[]): void;
|
381 | writePackedInt32String(field: number, value?: string[]): void;
|
382 | writePackedInt64(field: number, value?: number[]): void;
|
383 | writePackedInt64String(field: number, value?: string[]): void;
|
384 | writePackedUint32(field: number, value?: number[]): void;
|
385 | writePackedUint32String(field: number, value?: string[]): void;
|
386 | writePackedUint64(field: number, value?: number[]): void;
|
387 | writePackedUint64String(field: number, value?: string[]): void;
|
388 | writePackedSint32(field: number, value?: number[]): void;
|
389 | writePackedSint64(field: number, value?: number[]): void;
|
390 | writePackedSint64String(field: number, value?: string[]): void;
|
391 | writePackedFixed32(field: number, value?: number[]): void;
|
392 | writePackedFixed64(field: number, value?: number[]): void;
|
393 | writePackedFixed64String(field: number, value?: string[]): void;
|
394 | writePackedSfixed32(field: number, value?: number[]): void;
|
395 | writePackedSfixed64(field: number, value?: number[]): void;
|
396 | writePackedSfixed64String(field: number, value?: string[]): void;
|
397 | writePackedFloat(field: number, value?: number[]): void;
|
398 | writePackedDouble(field: number, value?: number[]): void;
|
399 | writePackedBool(field: number, value?: boolean[]): void;
|
400 | writePackedEnum(field: number, value?: number[]): void;
|
401 | writePackedFixedHash64(field: number, value?: string[]): void;
|
402 | writePackedVarintHash64(field: number, value?: string[]): void;
|
403 | }
|
404 |
|
405 | export class BinaryEncoder {
|
406 | constructor();
|
407 | length(): number;
|
408 | end(): number[];
|
409 | writeSplitVarint64(lowBits: number, highBits: number): void;
|
410 | writeSplitFixed64(lowBits: number, highBits: number): void;
|
411 | writeUnsignedVarint32(value: number): void;
|
412 | writeSignedVarint32(value: number): void;
|
413 | writeUnsignedVarint64(value: number): void;
|
414 | writeSignedVarint64(value: number): void;
|
415 | writeZigzagVarint32(value: number): void;
|
416 | writeZigzagVarint64(value: number): void;
|
417 | writeZigzagVarint64String(value: string): void;
|
418 | writeUint8(value: number): void;
|
419 | writeUint16(value: number): void;
|
420 | writeUint32(value: number): void;
|
421 | writeUint64(value: number): void;
|
422 | writeInt8(value: number): void;
|
423 | writeInt16(value: number): void;
|
424 | writeInt32(value: number): void;
|
425 | writeInt64(value: number): void;
|
426 | writeInt64String(value: string): void;
|
427 | writeFloat(value: number): void;
|
428 | writeDouble(value: number): void;
|
429 | writeBool(value: boolean): void;
|
430 | writeEnum(value: number): void;
|
431 | writeBytes(bytes: Uint8Array): void;
|
432 | writeVarintHash64(hash: string): void;
|
433 | writeFixedHash64(hash: string): void;
|
434 | writeString(value: string): number;
|
435 | }
|
436 |
|
437 | export class BinaryDecoder {
|
438 | constructor(bytes?: ByteSource, start?: number, length?: number)
|
439 | static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryDecoder;
|
440 | free(): void;
|
441 | clone(): BinaryDecoder;
|
442 | clear(): void;
|
443 | getBuffer(): Uint8Array;
|
444 | setBlock(data: ByteSource, start?: number, length?: number): void;
|
445 | getEnd(): number;
|
446 | setEnd(end: number): void;
|
447 | reset(): void;
|
448 | getCursor(): number;
|
449 | setCursor(cursor: number): void;
|
450 | advance(count: number): void;
|
451 | atEnd(): boolean;
|
452 | pastEnd(): boolean;
|
453 | getError(): boolean;
|
454 | skipVarint(): void;
|
455 | unskipVarint(value: number): void;
|
456 | readUnsignedVarint32(): number;
|
457 | readSignedVarint32(): number;
|
458 | readUnsignedVarint32String(): number;
|
459 | readSignedVarint32String(): number;
|
460 | readZigzagVarint32(): number;
|
461 | readUnsignedVarint64(): number;
|
462 | readUnsignedVarint64String(): number;
|
463 | readSignedVarint64(): number;
|
464 | readSignedVarint64String(): number;
|
465 | readZigzagVarint64(): number;
|
466 | readZigzagVarint64String(): number;
|
467 | readUint8(): number;
|
468 | readUint16(): number;
|
469 | readUint32(): number;
|
470 | readUint64(): number;
|
471 | readUint64String(): string;
|
472 | readInt8(): number;
|
473 | readInt16(): number;
|
474 | readInt32(): number;
|
475 | readInt64(): number;
|
476 | readInt64String(): string;
|
477 | readFloat(): number;
|
478 | readDouble(): number;
|
479 | readBool(): boolean;
|
480 | readEnum(): number;
|
481 | readString(length: number): string;
|
482 | readStringWithLength(): string;
|
483 | readBytes(length: number): Uint8Array;
|
484 | readVarintHash64(): string;
|
485 | readFixedHash64(): string;
|
486 | }
|
487 |
|
488 | export class BinaryIterator {
|
489 | constructor(
|
490 | decoder?: BinaryDecoder, next?: () => number | boolean | string | null,
|
491 | elements?: Array<number | boolean | string>)
|
492 | static alloc(
|
493 | decoder?: BinaryDecoder,
|
494 | next?: () => number | boolean | string | null,
|
495 | elements?: Array<number | boolean | string>): BinaryIterator;
|
496 | free(): void;
|
497 | clear(): void;
|
498 | get(): ScalarFieldType | null;
|
499 | atEnd(): boolean;
|
500 | next(): ScalarFieldType | null;
|
501 | }
|
502 |
|
503 | export namespace BinaryConstants {
|
504 | enum FieldType {
|
505 | INVALID = -1,
|
506 | DOUBLE = 1,
|
507 | FLOAT = 2,
|
508 | INT64 = 3,
|
509 | UINT64 = 4,
|
510 | INT32 = 5,
|
511 | FIXED64 = 6,
|
512 | FIXED32 = 7,
|
513 | BOOL = 8,
|
514 | STRING = 9,
|
515 | GROUP = 10,
|
516 | MESSAGE = 11,
|
517 | BYTES = 12,
|
518 | UINT32 = 13,
|
519 | ENUM = 14,
|
520 | SFIXED32 = 15,
|
521 | SFIXED64 = 16,
|
522 | SINT32 = 17,
|
523 | SINT64 = 18,
|
524 | FHASH64 = 30,
|
525 | VHASH64 = 31,
|
526 | }
|
527 |
|
528 | enum WireType {
|
529 | INVALID = -1,
|
530 | VARINT = 0,
|
531 | FIXED64 = 1,
|
532 | DELIMITED = 2,
|
533 | START_GROUP = 3,
|
534 | END_GROUP = 4,
|
535 | FIXED32 = 5,
|
536 | }
|
537 |
|
538 | const FieldTypeToWireType: (fieldType: FieldType) => WireType;
|
539 |
|
540 | const INVALID_FIELD_NUMBER: number;
|
541 | const FLOAT32_EPS: number;
|
542 | const FLOAT32_MIN: number;
|
543 | const FLOAT32_MAX: number;
|
544 | const FLOAT64_EPS: number;
|
545 | const FLOAT64_MIN: number;
|
546 | const FLOAT64_MAX: number;
|
547 | const TWO_TO_20: number;
|
548 | const TWO_TO_23: number;
|
549 | const TWO_TO_31: number;
|
550 | const TWO_TO_32: number;
|
551 | const TWO_TO_52: number;
|
552 | const TWO_TO_63: number;
|
553 | const TWO_TO_64: number;
|
554 | const ZERO_HASH: string;
|
555 | }
|
556 |
|
557 | export namespace arith {
|
558 | class UInt64 {
|
559 | lo: number;
|
560 | hi: number;
|
561 | constructor(lo: number, hi: number);
|
562 | cmp(other: UInt64): number;
|
563 | rightShift(): UInt64;
|
564 | leftShift(): UInt64;
|
565 | msb(): boolean;
|
566 | lsb(): boolean;
|
567 | zero(): boolean;
|
568 | add(other: UInt64): UInt64;
|
569 | sub(other: UInt64): UInt64;
|
570 | static mul32x32(a: number, b: number): UInt64;
|
571 | mul(a: number): UInt64;
|
572 | div(divisor: number): [UInt64, UInt64];
|
573 | toString(): string;
|
574 | static fromString(str: string): UInt64;
|
575 | clone(): UInt64;
|
576 | }
|
577 |
|
578 | class Int64 {
|
579 | lo: number;
|
580 | hi: number;
|
581 | constructor(lo: number, hi: number);
|
582 | add(other: Int64): Int64;
|
583 | sub(other: Int64): Int64;
|
584 | clone(): Int64;
|
585 | toString(): string;
|
586 | static fromString(str: string): Int64;
|
587 | }
|
588 | }
|
589 |
|
590 | // jspb.utils package excluded as it likely shouldn't be called by user code
|