UNPKG

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