protobufjs 8.1.6-experimental → 8.2.0

package/index.d.ts

@@ -261,6 +261,16 @@ export class Field extends FieldBase {
      */
     constructor(name: string, id: number, type: string, rule?: (string|{ [k: string]: any }), extend?: (string|{ [k: string]: any }), options?: { [k: string]: any });
 
+    /**
+     * Field decorator (TypeScript).
+     * @param fieldId Field id
+     * @param fieldType Field type
+     * @param [fieldRule="optional"] Field rule
+     * @returns Decorator function
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
+     */
+    public static d<T extends Message<T>>(fieldId: number, fieldType: (Constructor<T>|string), fieldRule?: ("optional"|"required"|"repeated")): FieldDecorator;
+
     /**
      * Constructs a field from a field descriptor.
      * @param name Field name
@@ -295,17 +305,9 @@ export class Field extends FieldBase {
      * @param [fieldRule="optional"] Field rule
      * @param [defaultValue] Default value
      * @returns Decorator function
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
     public static d<T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]>(fieldId: number, fieldType: ("double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"string"|"bool"|"bytes"|object), fieldRule?: ("optional"|"required"|"repeated"), defaultValue?: T): FieldDecorator;
-
-    /**
-     * Field decorator (TypeScript).
-     * @param fieldId Field id
-     * @param fieldType Field type
-     * @param [fieldRule="optional"] Field rule
-     * @returns Decorator function
-     */
-    public static d<T extends Message<T>>(fieldId: number, fieldType: (Constructor<T>|string), fieldRule?: ("optional"|"required"|"repeated")): FieldDecorator;
 }
 
 /** Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions. */
@@ -418,6 +420,7 @@ export interface IExtensionField extends IField {
  * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
  * @param prototype Target prototype
  * @param fieldName Field name
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 type FieldDecorator = (prototype: object, fieldName: string) => void;
 
@@ -512,6 +515,7 @@ export class MapField extends FieldBase {
      * @param fieldKeyType Field key type
      * @param fieldValueType Field value type
      * @returns Decorator function
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
     public static d<T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }>(fieldId: number, fieldKeyType: ("int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"), fieldValueType: ("double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"|"bytes"|object|Constructor<{}>)): FieldDecorator;
 }
@@ -539,6 +543,9 @@ export class Message<T extends object = object> {
      */
     constructor(properties?: Properties<T>);
 
+    /** Unknown fields preserved while decoding */
+    public $unknowns?: Uint8Array[];
+
     /** Reference to the reflected type. */
     public static readonly $type: Type;
 
@@ -624,9 +631,9 @@ export class Method extends ReflectionObject {
      * @param [responseStream] Whether the response is streamed
      * @param [options] Declared options
      * @param [comment] The comment for this method
-     * @param [parsedOptions] Declared options, properly parsed into an object
+     * @param [parsedOptions] Declared options, properly parsed into objects
      */
-    constructor(name: string, type: (string|undefined), requestType: string, responseType: string, requestStream?: (boolean|{ [k: string]: any }), responseStream?: (boolean|{ [k: string]: any }), options?: { [k: string]: any }, comment?: string, parsedOptions?: { [k: string]: any });
+    constructor(name: string, type: (string|undefined), requestType: string, responseType: string, requestStream?: (boolean|{ [k: string]: any }), responseStream?: (boolean|{ [k: string]: any }), options?: { [k: string]: any }, comment?: string, parsedOptions?: { [k: string]: any }[]);
 
     /** Method type. */
     public type: string;
@@ -652,8 +659,8 @@ export class Method extends ReflectionObject {
     /** Comment for this method */
     public comment: (string|null);
 
-    /** Options properly parsed into an object */
-    public parsedOptions: any;
+    /** Options properly parsed into objects */
+    public parsedOptions?: { [k: string]: any }[];
 
     /**
      * Constructs a method from a method descriptor.
@@ -696,8 +703,8 @@ export interface IMethod {
     /** Method comments */
     comment: string;
 
-    /** Method options properly parsed into an object */
-    parsedOptions?: { [k: string]: any };
+    /** Method options properly parsed into objects */
+    parsedOptions?: { [k: string]: any }[];
 }
 
 /** Reflected namespace. */
@@ -714,10 +721,11 @@ export class Namespace extends NamespaceBase {
      * Constructs a namespace from JSON.
      * @param name Namespace name
      * @param json JSON object
+     * @param [depth] Current nesting depth, defaults to `0`
      * @returns Created namespace
      * @throws {TypeError} If arguments are invalid
      */
-    public static fromJSON(name: string, json: { [k: string]: any }): Namespace;
+    public static fromJSON(name: string, json: { [k: string]: any }, depth?: number): Namespace;
 
     /**
      * Converts an array of reflection objects to JSON.
@@ -769,9 +777,10 @@ export abstract class NamespaceBase extends ReflectionObject {
     /**
      * Adds nested objects to this namespace from nested object descriptors.
      * @param nestedJson Any nested object descriptors
+     * @param [depth] Current nesting depth, defaults to `0`
      * @returns `this`
      */
-    public addJSON(nestedJson: { [k: string]: AnyNestedObject }): Namespace;
+    public addJSON(nestedJson: { [k: string]: AnyNestedObject }, depth?: number): Namespace;
 
     /**
      * Gets the nested object of the specified name.
@@ -898,7 +907,7 @@ export abstract class ReflectionObject {
     public options?: { [k: string]: any };
 
     /** Parsed Options. */
-    public parsedOptions?: { [k: string]: any[] };
+    public parsedOptions?: { [k: string]: any }[];
 
     /** Unique name within its namespace. */
     public name: string;
@@ -1074,6 +1083,7 @@ export class OneOf extends ReflectionObject {
      * OneOf decorator (TypeScript).
      * @param fieldNames Field names
      * @returns Decorator function
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
     public static d<T extends string>(...fieldNames: string[]): OneOfDecorator;
 }
@@ -1092,6 +1102,7 @@ export interface IOneOf {
  * Decorator function as returned by {@link OneOf.d} (TypeScript).
  * @param prototype Target prototype
  * @param oneofName OneOf name
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 type OneOfDecorator = (prototype: object, oneofName: string) => void;
 
@@ -1174,12 +1185,26 @@ export class Reader {
      */
     public static create(buffer: (Uint8Array|Buffer)): (Reader|BufferReader);
 
+    /**
+     * Returns raw bytes from the backing buffer without advancing the reader.
+     * @param start Start offset
+     * @param end End offset
+     * @returns Raw bytes
+     */
+    public raw(start: number, end: number): Uint8Array;
+
     /**
      * Reads a varint as an unsigned 32 bit value.
      * @returns Value read
      */
     public uint32(): number;
 
+    /**
+     * Reads a field tag.
+     * @returns Tag read
+     */
+    public tag(): number;
+
     /**
      * Reads a varint as a signed 32 bit value.
      * @returns Value read
@@ -1271,12 +1296,17 @@ export class Reader {
      */
     public skip(length?: number): Reader;
 
+    /** Recursion limit. */
+    public static recursionLimit: number;
+
     /**
      * Skips the next element of the specified wire type.
      * @param wireType Wire type received
+     * @param [depth] Depth of recursion to control nested calls; 0 if omitted
+     * @param [fieldNumber] Field number for validating group end tags
      * @returns `this`
      */
-    public skipType(wireType: number): Reader;
+    public skipType(wireType: number, depth?: number, fieldNumber?: number): Reader;
 }
 
 /** Wire format reader using node buffers. */
@@ -1288,6 +1318,14 @@ export class BufferReader extends Reader {
      */
     constructor(buffer: Buffer);
 
+    /**
+     * Returns raw bytes from the backing buffer without advancing the reader.
+     * @param start Start offset
+     * @param end End offset
+     * @returns Raw bytes
+     */
+    public raw(start: number, end: number): Buffer;
+
     /**
      * Reads a sequence of bytes preceeded by its length as a varint.
      * @returns Value read
@@ -1314,9 +1352,10 @@ export class Root extends NamespaceBase {
      * Loads a namespace descriptor into a root namespace.
      * @param json Namespace descriptor
      * @param [root] Root namespace, defaults to create a new one if omitted
+     * @param [depth] Current nesting depth, defaults to `0`
      * @returns Root namespace
      */
-    public static fromJSON(json: INamespace, root?: Root): Root;
+    public static fromJSON(json: INamespace, root?: Root, depth?: number): Root;
 
     /**
      * Resolves the path of an imported file, relative to the importing origin.
@@ -1467,10 +1506,11 @@ export class Service extends NamespaceBase {
      * Constructs a service from a service descriptor.
      * @param name Service name
      * @param json Service descriptor
+     * @param [depth] Current nesting depth, defaults to `0`
      * @returns Created service
      * @throws {TypeError} If arguments are invalid
      */
-    public static fromJSON(name: string, json: IService): Service;
+    public static fromJSON(name: string, json: IService, depth?: number): Service;
 
     /**
      * Converts this service to a service descriptor.
@@ -1621,9 +1661,10 @@ export class Type extends NamespaceBase {
      * Creates a message type from a message type descriptor.
      * @param name Message name
      * @param json Message type descriptor
+     * @param [depth] Current nesting depth, defaults to `0`
      * @returns Created message type
      */
-    public static fromJSON(name: string, json: IType): Type;
+    public static fromJSON(name: string, json: IType, depth?: number): Type;
 
     /**
      * Converts this message type to a message type descriptor.
@@ -1734,10 +1775,18 @@ export class Type extends NamespaceBase {
      */
     public toObject(message: Message<{}>, options?: IConversionOptions): { [k: string]: any };
 
+    /**
+     * Gets the type url for this type.
+     * @param [prefix] Custom type url prefix, defaults to `"type.googleapis.com"`
+     * @returns The type url
+     */
+    public getTypeUrl(prefix?: string): string;
+
     /**
      * Type decorator (TypeScript).
      * @param [typeName] Type name, defaults to the constructor's name
      * @returns Decorator function
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
     public static d<T extends Message<T>>(typeName?: string): TypeDecorator<T>;
 }
@@ -1804,6 +1853,7 @@ export interface IConversionOptions {
 /**
  * Decorator function as returned by {@link Type.d} (TypeScript).
  * @param target Target constructor
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 type TypeDecorator<T extends Message<T>> = (target: Constructor<T>) => void;
 
@@ -1900,6 +1950,45 @@ export interface Constructor<T> extends Function {
 /** Properties type. */
 type Properties<T> = { [P in keyof T]?: T[P] };
 
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @param error Error, if any
+ * @param params Additional arguments
+ */
+type asPromiseCallback = (error: (Error|null), ...params: any[]) => void;
+
+/**
+ * Appends code to the function's body or finishes generation.
+ * @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+ * @param [formatParams] Format parameters
+ * @returns Itself or the generated function if finished
+ * @throws {Error} If format parameter counts do not match
+ */
+type Codegen = (formatStringOrScope?: (string|{ [k: string]: any }), ...formatParams: any[]) => (Codegen|Function);
+
+/**
+ * Event listener as used by {@link util.EventEmitter}.
+ * @param args Arguments
+ */
+type EventEmitterListener = (...args: any[]) => void;
+
+/**
+ * Node-style callback as used by {@link util.fetch}.
+ * @param error Error, if any, otherwise `null`
+ * @param [contents] File contents, if there hasn't been an error
+ */
+type FetchCallback = (error: Error, contents?: string) => void;
+
+/** Options as used by {@link util.fetch}. */
+export interface IFetchOptions {
+
+    /** Whether expecting a binary response */
+    binary?: boolean;
+
+    /** If `true`, forces the use of XMLHttpRequest */
+    xhr?: boolean;
+}
+
 /**
  * Any compatible Buffer instance.
  * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
@@ -1935,526 +2024,487 @@ type OneOfGetter = () => (string|undefined);
  */
 type OneOfSetter = (value: (string|undefined)) => void;
 
-/** Various utility functions. */
-export namespace util {
-
-    /** Helper class for working with the low and high bits of a 64 bit value. */
-    class LongBits {
-
-        /**
-         * Constructs new long bits.
-         * @param lo Low 32 bits, unsigned
-         * @param hi High 32 bits, unsigned
-         */
-        constructor(lo: number, hi: number);
+/**
+ * An allocator as used by {@link util.pool}.
+ * @param size Buffer size
+ * @returns Buffer
+ */
+type PoolAllocator = (size: number) => Uint8Array;
 
-        /** Low bits. */
-        public lo: number;
+/**
+ * A slicer as used by {@link util.pool}.
+ * @param start Start offset
+ * @param end End offset
+ * @returns Buffer slice
+ */
+type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
 
-        /** High bits. */
-        public hi: number;
+/** Various utility functions. */
+export namespace util {
 
-        /** Zero bits. */
-        public static zero: util.LongBits;
+    /**
+     * Returns a promise from a node-style callback function.
+     * @param fn Function to call
+     * @param ctx Function context
+     * @param params Function arguments
+     * @returns Promisified function
+     */
+    function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
 
-        /** Zero hash. */
-        public static zeroHash: string;
+    /** A minimal base64 implementation for number arrays. */
+    namespace base64 {
 
         /**
-         * Constructs new long bits from the specified number.
-         * @param value Value
-         * @returns Instance
+         * Calculates the byte length of a base64 encoded string.
+         * @param string Base64 encoded string
+         * @returns Byte length
          */
-        public static fromNumber(value: number): util.LongBits;
+        function length(string: string): number;
 
         /**
-         * Constructs new long bits from a number, long or string.
-         * @param value Value
-         * @returns Instance
+         * Encodes a buffer to a base64 encoded string.
+         * @param buffer Source buffer
+         * @param start Source start
+         * @param end Source end
+         * @returns Base64 encoded string
          */
-        public static from(value: (Long|number|string)): util.LongBits;
+        function encode(buffer: Uint8Array, start: number, end: number): string;
 
         /**
-         * Converts this long bits to a possibly unsafe JavaScript number.
-         * @param [unsigned=false] Whether unsigned or not
-         * @returns Possibly unsafe number
+         * Decodes a base64 encoded string to a buffer.
+         * @param string Source string
+         * @param buffer Destination buffer
+         * @param offset Destination offset
+         * @returns Number of bytes written
+         * @throws {Error} If encoding is invalid
          */
-        public toNumber(unsigned?: boolean): number;
+        function decode(string: string, buffer: Uint8Array, offset: number): number;
 
         /**
-         * Converts this long bits to a long.
-         * @param [unsigned=false] Whether unsigned or not
-         * @returns Long
+         * Tests if the specified string appears to be base64 encoded.
+         * @param string String to test
+         * @returns `true` if probably base64 encoded, otherwise false
          */
-        public toLong(unsigned?: boolean): Long;
+        function test(string: string): boolean;
+    }
 
-        /**
-         * Constructs new long bits from the specified 8 characters long hash.
-         * @param hash Hash
-         * @returns Bits
-         */
-        public static fromHash(hash: string): util.LongBits;
+    /**
+     * Begins generating a function.
+     * @param functionParams Function parameter names
+     * @param [functionName] Function name if not anonymous
+     * @returns Appender that appends code to the function's body
+     */
+    function codegen(functionParams: string[], functionName?: string): Codegen;
 
-        /**
-         * Converts this long bits to a 8 characters long hash.
-         * @returns Hash
-         */
-        public toHash(): string;
+    namespace codegen {
+
+        /** When set to `true`, codegen will log generated code to console. Useful for debugging. */
+        let verbose: boolean;
+    }
+
+    /**
+     * Begins generating a function.
+     * @param [functionName] Function name if not anonymous
+     * @returns Appender that appends code to the function's body
+     */
+    function codegen(functionName?: string): Codegen;
+
+    /** A minimal event emitter. */
+    class EventEmitter {
+
+        /** Constructs a new event emitter instance. */
+        constructor();
 
         /**
-         * Zig-zag encodes this long bits.
+         * Registers an event listener.
+         * @param evt Event name
+         * @param fn Listener
+         * @param [ctx] Listener context
          * @returns `this`
          */
-        public zzEncode(): util.LongBits;
+        public on(evt: string, fn: EventEmitterListener, ctx?: any): this;
 
         /**
-         * Zig-zag decodes this long bits.
+         * Removes an event listener or any matching listeners if arguments are omitted.
+         * @param [evt] Event name. Removes all listeners if omitted.
+         * @param [fn] Listener to remove. Removes all listeners of `evt` if omitted.
          * @returns `this`
          */
-        public zzDecode(): util.LongBits;
+        public off(evt?: string, fn?: EventEmitterListener): this;
 
         /**
-         * Calculates the length of this longbits when encoded as a varint.
-         * @returns Length
+         * Emits an event by calling its listeners with the specified arguments.
+         * @param evt Event name
+         * @param args Arguments
+         * @returns `this`
          */
-        public length(): number;
+        public emit(evt: string, ...args: any[]): this;
     }
 
-    /** Whether running within node or not. */
-    let isNode: boolean;
-
-    /** Global object reference. */
-    let global: object;
-
-    /** An immuable empty array. */
-    const emptyArray: any[];
-
-    /** An immutable empty object. */
-    const emptyObject: object;
-
     /**
-     * Tests if the specified value is an integer.
-     * @param value Value to test
-     * @returns `true` if the value is an integer
+     * Fetches the contents of a file.
+     * @param filename File path or url
+     * @param options Fetch options
+     * @param callback Callback function
      */
-    function isInteger(value: any): boolean;
+    function fetch(filename: string, options: IFetchOptions, callback: FetchCallback): void;
 
     /**
-     * Tests if the specified value is a string.
-     * @param value Value to test
-     * @returns `true` if the value is a string
+     * Fetches the contents of a file.
+     * @param path File path or url
+     * @param callback Callback function
      */
-    function isString(value: any): boolean;
+    function fetch(path: string, callback: FetchCallback): void;
 
     /**
-     * Tests if the specified value is a non-null object.
-     * @param value Value to test
-     * @returns `true` if the value is a non-null object
+     * Fetches the contents of a file.
+     * @param path File path or url
+     * @param [options] Fetch options
+     * @returns Promise
      */
-    function isObject(value: any): boolean;
+    function fetch(path: string, options?: IFetchOptions): Promise<(string|Uint8Array)>;
 
-    /**
-     * Checks if a property on a message is considered to be present.
-     * This is an alias of {@link util.isSet}.
-     * @param obj Plain object or message instance
-     * @param prop Property name
-     * @returns `true` if considered to be present, otherwise `false`
-     */
-    function isset(obj: object, prop: string): boolean;
+    /** Reads / writes floats / doubles from / to buffers. */
+    namespace float {
 
-    /**
-     * Checks if a property on a message is considered to be present.
-     * @param obj Plain object or message instance
-     * @param prop Property name
-     * @returns `true` if considered to be present, otherwise `false`
-     */
-    function isSet(obj: object, prop: string): boolean;
+        /**
+         * Writes a 32 bit float to a buffer using little endian byte order.
+         * @param val Value to write
+         * @param buf Target buffer
+         * @param pos Target buffer offset
+         */
+        function writeFloatLE(val: number, buf: Uint8Array, pos: number): void;
 
-    /** Node's Buffer class if available. */
-    let Buffer: Constructor<Buffer>;
+        /**
+         * Writes a 32 bit float to a buffer using big endian byte order.
+         * @param val Value to write
+         * @param buf Target buffer
+         * @param pos Target buffer offset
+         */
+        function writeFloatBE(val: number, buf: Uint8Array, pos: number): void;
 
-    /**
-     * Creates a new buffer of whatever type supported by the environment.
-     * @param [sizeOrArray=0] Buffer size or number array
-     * @returns Buffer
-     */
-    function newBuffer(sizeOrArray?: (number|number[])): (Uint8Array|Buffer);
+        /**
+         * Reads a 32 bit float from a buffer using little endian byte order.
+         * @param buf Source buffer
+         * @param pos Source buffer offset
+         * @returns Value read
+         */
+        function readFloatLE(buf: Uint8Array, pos: number): number;
 
-    /** Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`. */
-    let Array: Constructor<Uint8Array>;
+        /**
+         * Reads a 32 bit float from a buffer using big endian byte order.
+         * @param buf Source buffer
+         * @param pos Source buffer offset
+         * @returns Value read
+         */
+        function readFloatBE(buf: Uint8Array, pos: number): number;
 
-    /** Long.js's Long class if available. */
-    let Long: Constructor<Long>;
+        /**
+         * Writes a 64 bit double to a buffer using little endian byte order.
+         * @param val Value to write
+         * @param buf Target buffer
+         * @param pos Target buffer offset
+         */
+        function writeDoubleLE(val: number, buf: Uint8Array, pos: number): void;
 
-    /** Regular expression used to verify 2 bit (`bool`) map keys. */
-    const key2Re: RegExp;
+        /**
+         * Writes a 64 bit double to a buffer using big endian byte order.
+         * @param val Value to write
+         * @param buf Target buffer
+         * @param pos Target buffer offset
+         */
+        function writeDoubleBE(val: number, buf: Uint8Array, pos: number): void;
 
-    /** Regular expression used to verify 32 bit (`int32` etc.) map keys. */
-    const key32Re: RegExp;
+        /**
+         * Reads a 64 bit double from a buffer using little endian byte order.
+         * @param buf Source buffer
+         * @param pos Source buffer offset
+         * @returns Value read
+         */
+        function readDoubleLE(buf: Uint8Array, pos: number): number;
 
-    /** Regular expression used to verify 64 bit (`int64` etc.) map keys. */
-    const key64Re: RegExp;
+        /**
+         * Reads a 64 bit double from a buffer using big endian byte order.
+         * @param buf Source buffer
+         * @param pos Source buffer offset
+         * @returns Value read
+         */
+        function readDoubleBE(buf: Uint8Array, pos: number): number;
+    }
 
     /**
-     * Converts a number or long to an 8 characters long hash string.
-     * @param value Value to convert
-     * @returns Hash
+     * Requires a module only if available.
+     * @param moduleName Module to require
+     * @returns Required module if available and not empty, otherwise `null`
+     * @deprecated Legacy optional require helper. Will be removed in a future release.
      */
-    function longToHash(value: (Long|number)): string;
+    function inquire(moduleName: string): object;
 
-    /**
-     * Converts an 8 characters long hash string to a long or number.
-     * @param hash Hash
-     * @param [unsigned=false] Whether unsigned or not
-     * @returns Original value
-     */
-    function longFromHash(hash: string, unsigned?: boolean): (Long|number);
+    /** Helper class for working with the low and high bits of a 64 bit value. */
+    class LongBits {
 
-    /**
-     * Merges the properties of the source object into the destination object.
-     * @param dst Destination object
-     * @param src Source object
-     * @param [ifNotSet=false] Merges only if the key is not already set
-     * @returns Destination object
-     */
-    function merge(dst: { [k: string]: any }, src: { [k: string]: any }, ifNotSet?: boolean): { [k: string]: any };
+        /**
+         * Constructs new long bits.
+         * @param lo Low 32 bits, unsigned
+         * @param hi High 32 bits, unsigned
+         */
+        constructor(lo: number, hi: number);
 
-    /**
-     * Converts the first character of a string to lower case.
-     * @param str String to convert
-     * @returns Converted string
-     */
-    function lcFirst(str: string): string;
+        /** Low bits. */
+        public lo: number;
 
-    /**
-     * Creates a custom error constructor.
-     * @param name Error name
-     * @returns Custom error constructor
-     */
-    function newError(name: string): Constructor<Error>;
+        /** High bits. */
+        public hi: number;
 
-    /** Error subclass indicating a protocol specifc error. */
-    class ProtocolError<T extends Message<T>> extends Error {
+        /** Zero bits. */
+        public static zero: util.LongBits;
+
+        /** Zero hash. */
+        public static zeroHash: string;
 
         /**
-         * Constructs a new protocol error.
-         * @param message Error message
-         * @param [properties] Additional properties
+         * Constructs new long bits from the specified number.
+         * @param value Value
+         * @returns Instance
          */
-        constructor(message: string, properties?: { [k: string]: any });
+        public static fromNumber(value: number): util.LongBits;
 
-        /** So far decoded message instance. */
-        public instance: Message<T>;
-    }
+        /**
+         * Constructs new long bits from a number, long or string.
+         * @param value Value
+         * @returns Instance
+         */
+        public static from(value: (Long|number|string)): util.LongBits;
 
-    /**
-     * Builds a getter for a oneof's present field name.
-     * @param fieldNames Field names
-     * @returns Unbound getter
-     */
-    function oneOfGetter(fieldNames: string[]): OneOfGetter;
+        /**
+         * Converts this long bits to a possibly unsafe JavaScript number.
+         * @param [unsigned=false] Whether unsigned or not
+         * @returns Possibly unsafe number
+         */
+        public toNumber(unsigned?: boolean): number;
 
-    /**
-     * Builds a setter for a oneof's present field name.
-     * @param fieldNames Field names
-     * @returns Unbound setter
-     */
-    function oneOfSetter(fieldNames: string[]): OneOfSetter;
+        /**
+         * Converts this long bits to a long.
+         * @param [unsigned=false] Whether unsigned or not
+         * @returns Long
+         */
+        public toLong(unsigned?: boolean): Long;
 
-    /**
-     * Default conversion options used for {@link Message#toJSON} implementations.
-     *
-     * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
-     *
-     * - Longs become strings
-     * - Enums become string keys
-     * - Bytes become base64 encoded strings
-     * - (Sub-)Messages become plain objects
-     * - Maps become plain objects with all string keys
-     * - Repeated fields become arrays
-     * - NaN and Infinity for float and double fields become strings
-     *
-     * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
-     */
-    let toJSONOptions: IConversionOptions;
+        /**
+         * Constructs new long bits from the specified 8 characters long hash.
+         * @param hash Hash
+         * @returns Bits
+         */
+        public static fromHash(hash: string): util.LongBits;
 
-    /** Node's fs module if available. */
-    let fs: { [k: string]: any };
+        /**
+         * Converts this long bits to a 8 characters long hash.
+         * @returns Hash
+         */
+        public toHash(): string;
 
-    /**
-     * Converts an object's values to an array.
-     * @param object Object to convert
-     * @returns Converted array
-     */
-    function toArray(object: { [k: string]: any }): any[];
+        /**
+         * Zig-zag encodes this long bits.
+         * @returns `this`
+         */
+        public zzEncode(): util.LongBits;
 
-    /**
-     * Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.
-     * @param array Array to convert
-     * @returns Converted object
-     */
-    function toObject(array: any[]): { [k: string]: any };
+        /**
+         * Zig-zag decodes this long bits.
+         * @returns `this`
+         */
+        public zzDecode(): util.LongBits;
 
-    /**
-     * Tests whether the specified name is a reserved word in JS.
-     * @param name Name to test
-     * @returns `true` if reserved, otherwise `false`
-     */
-    function isReserved(name: string): boolean;
+        /**
+         * Calculates the length of this longbits when encoded as a varint.
+         * @returns Length
+         */
+        public length(): number;
+    }
 
-    /**
-     * Returns a safe property accessor for the specified property name.
-     * @param prop Property name
-     * @returns Safe accessor
-     */
-    function safeProp(prop: string): string;
+    /** Whether running within node or not. */
+    let isNode: boolean;
 
-    /**
-     * Converts the first character of a string to upper case.
-     * @param str String to convert
-     * @returns Converted string
-     */
-    function ucFirst(str: string): string;
+    /** Global object reference. */
+    let global: object;
+
+    /** An immuable empty array. */
+    const emptyArray: any[];
+
+    /** An immutable empty object. */
+    const emptyObject: object;
 
     /**
-     * Converts a string to camel case.
-     * @param str String to convert
-     * @returns Converted string
+     * Tests if the specified value is an integer.
+     * @param value Value to test
+     * @returns `true` if the value is an integer
      */
-    function camelCase(str: string): string;
+    function isInteger(value: any): boolean;
 
     /**
-     * Compares reflected fields by id.
-     * @param a First field
-     * @param b Second field
-     * @returns Comparison value
+     * Tests if the specified value is a string.
+     * @param value Value to test
+     * @returns `true` if the value is a string
      */
-    function compareFieldsById(a: Field, b: Field): number;
+    function isString(value: any): boolean;
 
     /**
-     * Decorator helper for types (TypeScript).
-     * @param ctor Constructor function
-     * @param [typeName] Type name, defaults to the constructor's name
-     * @returns Reflected type
+     * Tests if the specified value is a non-null object.
+     * @param value Value to test
+     * @returns `true` if the value is a non-null object
      */
-    function decorateType<T extends Message<T>>(ctor: Constructor<T>, typeName?: string): Type;
+    function isObject(value: any): boolean;
 
     /**
-     * Decorator helper for enums (TypeScript).
-     * @param object Enum object
-     * @returns Reflected enum
+     * Checks if a property on a message is considered to be present.
+     * This is an alias of {@link util.isSet}.
+     * @param obj Plain object or message instance
+     * @param prop Property name
+     * @returns `true` if considered to be present, otherwise `false`
      */
-    function decorateEnum(object: object): Enum;
+    function isset(obj: object, prop: string): boolean;
 
     /**
-     * Sets the value of a property by property path. If a value already exists, it is turned to an array
-     * @param dst Destination object
-     * @param path dot '.' delimited path of the property to set
-     * @param value the value to set
-     * @param [ifNotSet] Sets the option only if it isn't currently set
-     * @returns Destination object
+     * Checks if a property on a message is considered to be present.
+     * @param obj Plain object or message instance
+     * @param prop Property name
+     * @returns `true` if considered to be present, otherwise `false`
      */
-    function setProperty(dst: { [k: string]: any }, path: string, value: object, ifNotSet?: (boolean|undefined)): { [k: string]: any };
+    function isSet(obj: object, prop: string): boolean;
 
-    /** Decorator root (TypeScript). */
-    let decorateRoot: Root;
+    /** Node's Buffer class if available. */
+    let Buffer: Constructor<Buffer>;
 
     /**
-     * Returns a promise from a node-style callback function.
-     * @param fn Function to call
-     * @param ctx Function context
-     * @param params Function arguments
-     * @returns Promisified function
+     * Creates a new buffer of whatever type supported by the environment.
+     * @param [sizeOrArray=0] Buffer size or number array
+     * @returns Buffer
      */
-    function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
+    function newBuffer(sizeOrArray?: (number|number[])): (Uint8Array|Buffer);
 
-    /** A minimal base64 implementation for number arrays. */
-    namespace base64 {
+    /** Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`. */
+    let Array: Constructor<Uint8Array>;
 
-        /**
-         * Calculates the byte length of a base64 encoded string.
-         * @param string Base64 encoded string
-         * @returns Byte length
-         */
-        function length(string: string): number;
+    /** Long.js's Long class if available. */
+    let Long: Constructor<Long>;
 
-        /**
-         * Encodes a buffer to a base64 encoded string.
-         * @param buffer Source buffer
-         * @param start Source start
-         * @param end Source end
-         * @returns Base64 encoded string
-         */
-        function encode(buffer: Uint8Array, start: number, end: number): string;
+    /** Regular expression used to verify 2 bit (`bool`) map keys. */
+    const key2Re: RegExp;
 
-        /**
-         * Decodes a base64 encoded string to a buffer.
-         * @param string Source string
-         * @param buffer Destination buffer
-         * @param offset Destination offset
-         * @returns Number of bytes written
-         * @throws {Error} If encoding is invalid
-         */
-        function decode(string: string, buffer: Uint8Array, offset: number): number;
+    /** Regular expression used to verify 32 bit (`int32` etc.) map keys. */
+    const key32Re: RegExp;
 
-        /**
-         * Tests if the specified string appears to be base64 encoded.
-         * @param string String to test
-         * @returns `true` if probably base64 encoded, otherwise false
-         */
-        function test(string: string): boolean;
-    }
+    /** Regular expression used to verify 64 bit (`int64` etc.) map keys. */
+    const key64Re: RegExp;
 
     /**
-     * Begins generating a function.
-     * @param functionParams Function parameter names
-     * @param [functionName] Function name if not anonymous
-     * @returns Appender that appends code to the function's body
+     * Converts a number or long to an 8 characters long hash string.
+     * @param value Value to convert
+     * @returns Hash
      */
-    function codegen(functionParams: string[], functionName?: string): Codegen;
-
-    namespace codegen {
-
-        /** When set to `true`, codegen will log generated code to console. Useful for debugging. */
-        let verbose: boolean;
-    }
+    function longToHash(value: (Long|number)): string;
 
     /**
-     * Begins generating a function.
-     * @param [functionName] Function name if not anonymous
-     * @returns Appender that appends code to the function's body
+     * Converts an 8 characters long hash string to a long or number.
+     * @param hash Hash
+     * @param [unsigned=false] Whether unsigned or not
+     * @returns Original value
      */
-    function codegen(functionName?: string): Codegen;
-
-    /** A minimal event emitter. */
-    class EventEmitter {
-
-        /** Constructs a new event emitter instance. */
-        constructor();
-
-        /**
-         * Registers an event listener.
-         * @param evt Event name
-         * @param fn Listener
-         * @param [ctx] Listener context
-         * @returns `this`
-         */
-        public on(evt: string, fn: EventEmitterListener, ctx?: any): this;
-
-        /**
-         * Removes an event listener or any matching listeners if arguments are omitted.
-         * @param [evt] Event name. Removes all listeners if omitted.
-         * @param [fn] Listener to remove. Removes all listeners of `evt` if omitted.
-         * @returns `this`
-         */
-        public off(evt?: string, fn?: EventEmitterListener): this;
-
-        /**
-         * Emits an event by calling its listeners with the specified arguments.
-         * @param evt Event name
-         * @param args Arguments
-         * @returns `this`
-         */
-        public emit(evt: string, ...args: any[]): this;
-    }
+    function longFromHash(hash: string, unsigned?: boolean): (Long|number);
 
-    /** Reads / writes floats / doubles from / to buffers. */
-    namespace float {
+    /**
+     * Converts a 64 bit key to a long or number if it is an 8 characters long hash string.
+     * @param key Map key
+     * @param [unsigned=false] Whether unsigned or not
+     * @returns Original value
+     */
+    function longFromKey(key: string, unsigned?: boolean): (Long|number|string);
 
-        /**
-         * Writes a 32 bit float to a buffer using little endian byte order.
-         * @param val Value to write
-         * @param buf Target buffer
-         * @param pos Target buffer offset
-         */
-        function writeFloatLE(val: number, buf: Uint8Array, pos: number): void;
+    /**
+     * Converts a boolean key to a boolean value.
+     * @param key Map key
+     * @returns Boolean value
+     */
+    function boolFromKey(key: string): boolean;
 
-        /**
-         * Writes a 32 bit float to a buffer using big endian byte order.
-         * @param val Value to write
-         * @param buf Target buffer
-         * @param pos Target buffer offset
-         */
-        function writeFloatBE(val: number, buf: Uint8Array, pos: number): void;
+    /**
+     * Merges the properties of the source object into the destination object.
+     * @param dst Destination object
+     * @param src Source object
+     * @param [ifNotSet=false] Merges only if the key is not already set
+     * @returns Destination object
+     */
+    function merge(dst: { [k: string]: any }, src: { [k: string]: any }, ifNotSet?: boolean): { [k: string]: any };
 
-        /**
-         * Reads a 32 bit float from a buffer using little endian byte order.
-         * @param buf Source buffer
-         * @param pos Source buffer offset
-         * @returns Value read
-         */
-        function readFloatLE(buf: Uint8Array, pos: number): number;
+    /** Recursion limit. */
+    let recursionLimit: number;
 
-        /**
-         * Reads a 32 bit float from a buffer using big endian byte order.
-         * @param buf Source buffer
-         * @param pos Source buffer offset
-         * @returns Value read
-         */
-        function readFloatBE(buf: Uint8Array, pos: number): number;
+    /**
+     * Makes a property safe for assignment as an own property.
+     * @param obj Object
+     * @param key Property key
+     * @param [enumerable=true] Whether the property should be enumerable
+     */
+    function makeProp(obj: { [k: string]: any }, key: string, enumerable?: boolean): void;
 
-        /**
-         * Writes a 64 bit double to a buffer using little endian byte order.
-         * @param val Value to write
-         * @param buf Target buffer
-         * @param pos Target buffer offset
-         */
-        function writeDoubleLE(val: number, buf: Uint8Array, pos: number): void;
+    /**
+     * Converts the first character of a string to lower case.
+     * @param str String to convert
+     * @returns Converted string
+     */
+    function lcFirst(str: string): string;
 
-        /**
-         * Writes a 64 bit double to a buffer using big endian byte order.
-         * @param val Value to write
-         * @param buf Target buffer
-         * @param pos Target buffer offset
-         */
-        function writeDoubleBE(val: number, buf: Uint8Array, pos: number): void;
+    /**
+     * Creates a custom error constructor.
+     * @param name Error name
+     * @returns Custom error constructor
+     */
+    function newError(name: string): Constructor<Error>;
 
-        /**
-         * Reads a 64 bit double from a buffer using little endian byte order.
-         * @param buf Source buffer
-         * @param pos Source buffer offset
-         * @returns Value read
-         */
-        function readDoubleLE(buf: Uint8Array, pos: number): number;
+    /** Error subclass indicating a protocol specifc error. */
+    class ProtocolError<T extends Message<T>> extends Error {
 
         /**
-         * Reads a 64 bit double from a buffer using big endian byte order.
-         * @param buf Source buffer
-         * @param pos Source buffer offset
-         * @returns Value read
+         * Constructs a new protocol error.
+         * @param message Error message
+         * @param [properties] Additional properties
          */
-        function readDoubleBE(buf: Uint8Array, pos: number): number;
-    }
+        constructor(message: string, properties?: { [k: string]: any });
 
-    /**
-     * Fetches the contents of a file.
-     * @param filename File path or url
-     * @param options Fetch options
-     * @param callback Callback function
-     */
-    function fetch(filename: string, options: IFetchOptions, callback: FetchCallback): void;
+        /** So far decoded message instance. */
+        public instance: Message<T>;
+    }
 
     /**
-     * Fetches the contents of a file.
-     * @param path File path or url
-     * @param callback Callback function
+     * Builds a getter for a oneof's present field name.
+     * @param fieldNames Field names
+     * @returns Unbound getter
      */
-    function fetch(path: string, callback: FetchCallback): void;
+    function oneOfGetter(fieldNames: string[]): OneOfGetter;
 
     /**
-     * Fetches the contents of a file.
-     * @param path File path or url
-     * @param [options] Fetch options
-     * @returns Promise
+     * Builds a setter for a oneof's present field name.
+     * @param fieldNames Field names
+     * @returns Unbound setter
      */
-    function fetch(path: string, options?: IFetchOptions): Promise<(string|Uint8Array)>;
+    function oneOfSetter(fieldNames: string[]): OneOfSetter;
 
     /**
-     * Requires a module only if available.
-     * @param moduleName Module to require
-     * @returns Required module if available and not empty, otherwise `null`
+     * Default conversion options used for {@link Message#toJSON} implementations.
+     *
+     * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
+     *
+     * - Longs become strings
+     * - Enums become string keys
+     * - Bytes become base64 encoded strings
+     * - (Sub-)Messages become plain objects
+     * - Maps become plain objects with all string keys
+     * - Repeated fields become arrays
+     * - NaN and Infinity for float and double fields become strings
+     *
+     * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
      */
-    function inquire(moduleName: string): object;
+    let toJSONOptions: IConversionOptions;
 
     /** A minimal path module to resolve Unix, Windows and URL paths alike. */
     namespace path {
@@ -2520,6 +2570,100 @@ export namespace util {
          */
         function write(string: string, buffer: Uint8Array, offset: number): number;
     }
+
+    /** Node's fs module if available. */
+    let fs: { [k: string]: any };
+
+    /**
+     * Checks a recursion depth.
+     * @param depth Depth of recursion
+     * @returns Depth of recursion
+     * @throws {Error} If depth exceeds util.recursionLimit
+     */
+    function checkDepth(depth: (number|undefined)): number;
+
+    /**
+     * Converts an object's values to an array.
+     * @param object Object to convert
+     * @returns Converted array
+     */
+    function toArray(object: { [k: string]: any }): any[];
+
+    /**
+     * Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.
+     * @param array Array to convert
+     * @returns Converted object
+     */
+    function toObject(array: any[]): { [k: string]: any };
+
+    /**
+     * Tests whether the specified name is a reserved word in JS.
+     * @param name Name to test
+     * @returns `true` if reserved, otherwise `false`
+     */
+    function isReserved(name: string): boolean;
+
+    /**
+     * Returns a safe property accessor for the specified property name.
+     * @param prop Property name
+     * @returns Safe accessor
+     */
+    function safeProp(prop: string): string;
+
+    /**
+     * Converts the first character of a string to upper case.
+     * @param str String to convert
+     * @returns Converted string
+     */
+    function ucFirst(str: string): string;
+
+    /**
+     * Converts a string to camel case.
+     * @param str String to convert
+     * @returns Converted string
+     */
+    function camelCase(str: string): string;
+
+    /**
+     * Compares reflected fields by id.
+     * @param a First field
+     * @param b Second field
+     * @returns Comparison value
+     */
+    function compareFieldsById(a: Field, b: Field): number;
+
+    /**
+     * Decorator helper for types (TypeScript).
+     * @param ctor Constructor function
+     * @param [typeName] Type name, defaults to the constructor's name
+     * @returns Reflected type
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
+     */
+    function decorateType<T extends Message<T>>(ctor: Constructor<T>, typeName?: string): Type;
+
+    /**
+     * Decorator helper for enums (TypeScript).
+     * @param object Enum object
+     * @returns Reflected enum
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
+     */
+    function decorateEnum(object: object): Enum;
+
+    /**
+     * Sets the value of a property by property path. If a value already exists, it is turned to an array
+     * @param dst Destination object
+     * @param path dot '.' delimited path of the property to set
+     * @param value the value to set
+     * @param [ifNotSet] Sets the option only if it isn't currently set
+     * @returns Destination object
+     */
+    function setProperty(dst: { [k: string]: any }, path: string, value: object, ifNotSet?: (boolean|undefined)): { [k: string]: any };
+
+    /**
+     * Decorator root (TypeScript).
+     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
+     */
+    let decorateRoot: Root;
 }
 
 /**
@@ -2691,6 +2835,13 @@ export class Writer {
      */
     public bytes(value: (Uint8Array|string)): Writer;
 
+    /**
+     * Writes raw bytes without a tag or length prefix.
+     * @param value Raw bytes
+     * @returns `this`
+     */
+    public raw(value: Uint8Array): Writer;
+
     /**
      * Writes a string.
      * @param value Value to write
@@ -2722,6 +2873,16 @@ export class Writer {
      * @returns Finished buffer
      */
     public finish(): Uint8Array;
+
+    /**
+     * Finishes the write operation, writing into the provided buffer.
+     * The caller must ensure that `buf` has enough space starting at `offset`
+     * to hold {@link Writer#len} bytes.
+     * @param buf Target buffer
+     * @param [offset=0] Offset to start writing at
+     * @returns The provided buffer
+     */
+    public finishInto<T extends Uint8Array>(buf: T, offset?: number): T;
 }
 
 /** Wire format writer using node buffers. */
@@ -2737,63 +2898,16 @@ export class BufferWriter extends Writer {
      */
     public static alloc(size: number): Buffer;
 
+    /**
+     * Writes raw bytes without a tag or length prefix.
+     * @param value Raw bytes
+     * @returns `this`
+     */
+    public raw(value: Uint8Array): BufferWriter;
+
     /**
      * Finishes the write operation.
      * @returns Finished buffer
      */
     public finish(): Buffer;
 }
-
-/**
- * Callback as used by {@link util.asPromise}.
- * @param error Error, if any
- * @param params Additional arguments
- */
-type asPromiseCallback = (error: (Error|null), ...params: any[]) => void;
-
-/**
- * Appends code to the function's body or finishes generation.
- * @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
- * @param [formatParams] Format parameters
- * @returns Itself or the generated function if finished
- * @throws {Error} If format parameter counts do not match
- */
-type Codegen = (formatStringOrScope?: (string|{ [k: string]: any }), ...formatParams: any[]) => (Codegen|Function);
-
-/**
- * Event listener as used by {@link util.EventEmitter}.
- * @param args Arguments
- */
-type EventEmitterListener = (...args: any[]) => void;
-
-/**
- * Node-style callback as used by {@link util.fetch}.
- * @param error Error, if any, otherwise `null`
- * @param [contents] File contents, if there hasn't been an error
- */
-type FetchCallback = (error: Error, contents?: string) => void;
-
-/** Options as used by {@link util.fetch}. */
-export interface IFetchOptions {
-
-    /** Whether expecting a binary response */
-    binary?: boolean;
-
-    /** If `true`, forces the use of XMLHttpRequest */
-    xhr?: boolean;
-}
-
-/**
- * An allocator as used by {@link util.pool}.
- * @param size Buffer size
- * @returns Buffer
- */
-type PoolAllocator = (size: number) => Uint8Array;
-
-/**
- * A slicer as used by {@link util.pool}.
- * @param start Start offset
- * @param end End offset
- * @returns Buffer slice
- */
-type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;