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