nexus-agents 14.0.1 → 14.0.2

package/node_modules/protobufjs/index.d.ts

@@ -1,4 +1,4 @@
-// DO NOT EDIT! This is a generated file. Edit the source file instead and regenerate.
+// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run build:types'.
 
 export as namespace protobuf;
 
@@ -100,11 +100,6 @@ export namespace common {
         value?: Uint8Array;
     }
 
-    /** Properties of a google.protobuf.FieldMask message. */
-    interface IFieldMask {
-        paths?: string[];
-    }
-
     /**
      * Gets the root definition of the specified common proto file.
      *
@@ -167,31 +162,28 @@ export class Enum extends ReflectionObject {
      * @param [comments] The value comments for this enum
      * @param [valuesOptions] The value options for this enum
      */
-    constructor(name: string, values?: { [k: string]: number }, options?: { [k: string]: any }, comment?: string, comments?: { [k: string]: (string|null) }, valuesOptions?: ({ [k: string]: { [k: string]: any } }|undefined));
+    constructor(name: string, values?: { [k: string]: number }, options?: { [k: string]: any }, comment?: string, comments?: { [k: string]: string }, valuesOptions?: ({ [k: string]: { [k: string]: any } }|undefined));
 
     /** Enum values by id. */
-    valuesById: { [k: number]: string };
+    public valuesById: { [k: number]: string };
 
     /** Enum values by name. */
-    values: { [k: string]: number };
+    public values: { [k: string]: number };
 
     /** Enum comment text. */
-    comment: (string|null);
+    public comment: (string|null);
 
     /** Value comment texts, if any. */
-    comments: { [k: string]: (string|null) };
+    public comments: { [k: string]: string };
 
     /** Values options, if any */
-    valuesOptions?: { [k: string]: { [k: string]: any } };
+    public valuesOptions?: { [k: string]: { [k: string]: any } };
 
     /** Resolved values features, if any */
-    _valuesFeatures?: { [k: string]: { [k: string]: any } };
+    public _valuesFeatures?: { [k: string]: { [k: string]: any } };
 
     /** Reserved ranges, if any. */
-    reserved: (number[]|string)[];
-
-    /** Declared symbol visibility, if any. */
-    visibility?: ("local"|"export");
+    public reserved: (number[]|string)[];
 
     /**
      * Constructs an enum from an enum descriptor.
@@ -200,14 +192,14 @@ export class Enum extends ReflectionObject {
      * @returns Created enum
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IEnum): Enum;
+    public static fromJSON(name: string, json: IEnum): Enum;
 
     /**
      * Converts this enum to an enum descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Enum descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IEnum;
+    public toJSON(toJSONOptions?: IToJSONOptions): IEnum;
 
     /**
      * Adds a value to this enum.
@@ -219,7 +211,7 @@ export class Enum extends ReflectionObject {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If there is already a value with this name or id
      */
-    add(name: string, id: number, comment?: string, options?: ({ [k: string]: any }|undefined)): Enum;
+    public add(name: string, id: number, comment?: string, options?: ({ [k: string]: any }|undefined)): Enum;
 
     /**
      * Removes a value from this enum
@@ -228,49 +220,31 @@ export class Enum extends ReflectionObject {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If `name` is not a name of this enum
      */
-    remove(name: string): Enum;
+    public remove(name: string): Enum;
 
     /**
      * Tests if the specified id is reserved.
      * @param id Id to test
      * @returns `true` if reserved, otherwise `false`
      */
-    isReservedId(id: number): boolean;
+    public isReservedId(id: number): boolean;
 
     /**
      * Tests if the specified name is reserved.
      * @param name Name to test
      * @returns `true` if reserved, otherwise `false`
      */
-    isReservedName(name: string): boolean;
+    public isReservedName(name: string): boolean;
 }
 
 /** Enum descriptor. */
 export interface IEnum {
 
-    /** Edition */
-    edition?: string;
-
     /** Enum values */
     values: { [k: string]: number };
 
     /** Enum options */
     options?: { [k: string]: any };
-
-    /** Enum value options */
-    valuesOptions?: { [k: string]: { [k: string]: any } };
-
-    /** Reserved ranges */
-    reserved?: (number[]|string)[];
-
-    /** Declared symbol visibility */
-    visibility?: ("local"|"export");
-
-    /** Enum comment */
-    comment?: (string|null);
-
-    /** Value comments */
-    comments?: { [k: string]: (string|null) };
 }
 
 /** Reflected message field. */
@@ -287,16 +261,6 @@ 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.
-     */
-    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
@@ -304,48 +268,44 @@ export class Field extends FieldBase {
      * @returns Created field
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IField): Field;
+    public static fromJSON(name: string, json: IField): Field;
 
     /** Determines whether this field is required. */
-    readonly required: boolean;
+    public readonly required: boolean;
 
     /** Determines whether this field is not required. */
-    readonly optional: boolean;
+    public readonly optional: boolean;
 
     /**
      * Determines whether this field uses tag-delimited encoding.  In proto2 this
      * corresponded to group syntax.
      */
-    readonly delimited: boolean;
+    public readonly delimited: boolean;
 
     /** Determines whether this field is packed. Only relevant when repeated. */
-    readonly packed: boolean;
+    public readonly packed: boolean;
 
     /** Determines whether this field tracks presence. */
-    readonly hasPresence: boolean;
+    public readonly hasPresence: boolean;
 
     /**
-     * The field name as declared in the .proto source (snake_case). Populated on resolve,
-     * falling back to `name`. Mirrors `FieldDescriptorProto.name`.
-     */
-    readonly protoName: string;
-
-    /**
-     * The JSON name of this field (lowerCamelCase per protoc's `ToJsonName`, or an
-     * explicit `[json_name]`). Populated on resolve. This is the key used on ProtoJSON output.
+     * Field decorator (TypeScript).
+     * @param fieldId Field id
+     * @param fieldType Field type
+     * @param [fieldRule="optional"] Field rule
+     * @param [defaultValue] Default value
+     * @returns Decorator function
      */
-    readonly jsonName: string;
+    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
-     * @param [defaultValue] Default value
      * @returns Decorator function
-     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
-    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;
+    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. */
@@ -363,73 +323,64 @@ export class FieldBase extends ReflectionObject {
      */
     constructor(name: string, id: number, type: string, rule?: (string|{ [k: string]: any }), extend?: (string|{ [k: string]: any }), options?: { [k: string]: any }, comment?: string);
 
-    /** Field rule, if any. */
-    rule?: string;
-
     /** Field type. */
-    type: string;
+    public type: string;
 
     /** Unique field id. */
-    id: number;
+    public id: number;
 
     /** Extended type if different from parent. */
-    extend?: string;
+    public extend?: string;
 
     /** Whether this field is repeated. */
-    repeated: boolean;
+    public repeated: boolean;
 
     /** Whether this field is a map or not. */
-    map: boolean;
+    public map: boolean;
 
     /** Message this field belongs to. */
-    message: (Type|null);
+    public message: (Type|null);
 
     /** OneOf this field belongs to, if any, */
-    partOf: (OneOf|null);
+    public partOf: (OneOf|null);
 
     /** The field type's default value. */
-    typeDefault: any;
+    public typeDefault: any;
 
     /** The field's default value on prototypes. */
-    defaultValue: any;
+    public defaultValue: any;
 
     /** Whether this field's value should be treated as a long. */
-    long: boolean;
+    public long: boolean;
 
     /** Whether this field's value is a buffer. */
-    bytes: boolean;
+    public bytes: boolean;
 
     /** Resolved type if not a basic type. */
-    resolvedType: (Type|Enum|null);
+    public resolvedType: (Type|Enum|null);
 
     /** Sister-field within the extended type if a declaring extension field. */
-    extensionField: (Field|null);
+    public extensionField: (Field|null);
 
     /** Sister-field within the declaring namespace if an extended field. */
-    declaringField: (Field|null);
+    public declaringField: (Field|null);
 
     /** Comment for this field. */
-    comment: (string|null);
-
-    /** Field name as declared in the .proto source, if different from `name`. */
-    protoName?: string;
-
-    /** JSON name, if different from the derived default. */
-    jsonName?: string;
+    public comment: (string|null);
 
     /**
      * Converts this field to a field descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Field descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IField;
+    public toJSON(toJSONOptions?: IToJSONOptions): IField;
 
     /**
      * Resolves this field's type references.
      * @returns `this`
      * @throws {Error} If any reference cannot be resolved
      */
-    resolve(): Field;
+    public resolve(): Field;
 
     /**
      * Infers field features from legacy syntax that may have been specified differently.
@@ -437,15 +388,12 @@ export class FieldBase extends ReflectionObject {
      * @param edition The edition this proto is on, or undefined if pre-editions
      * @returns The feature values to override
      */
-    _inferLegacyProtoFeatures(edition: (string|undefined)): object;
+    public _inferLegacyProtoFeatures(edition: (string|undefined)): object;
 }
 
 /** Field descriptor. */
 export interface IField {
 
-    /** Edition */
-    edition?: string;
-
     /** Field rule */
     rule?: string;
 
@@ -457,9 +405,6 @@ export interface IField {
 
     /** Field options */
     options?: { [k: string]: any };
-
-    /** Field comment */
-    comment?: (string|null);
 }
 
 /** Extension field descriptor. */
@@ -473,16 +418,15 @@ 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.
  */
-export type FieldDecorator = (prototype: object, fieldName: string) => void;
+type FieldDecorator = (prototype: object, fieldName: string) => void;
 
 /**
  * A node-style callback as used by {@link load} and {@link Root#load}.
  * @param error Error, if any, otherwise `null`
  * @param [root] Root, if there hasn't been an error
  */
-export type LoadCallback = (error: (Error|null), root?: Root) => void;
+type LoadCallback = (error: (Error|null), root?: Root) => void;
 
 /**
  * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
@@ -541,10 +485,10 @@ export class MapField extends FieldBase {
     constructor(name: string, id: number, keyType: string, type: string, options?: { [k: string]: any }, comment?: string);
 
     /** Key type. */
-    keyType: string;
+    public keyType: string;
 
     /** Resolved key type if not a basic type. */
-    resolvedKeyType: (ReflectionObject|null);
+    public resolvedKeyType: (ReflectionObject|null);
 
     /**
      * Constructs a map field from a map field descriptor.
@@ -553,14 +497,14 @@ export class MapField extends FieldBase {
      * @returns Created map field
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IMapField): MapField;
+    public static fromJSON(name: string, json: IMapField): MapField;
 
     /**
      * Converts this map field to a map field descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Map field descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IMapField;
+    public toJSON(toJSONOptions?: IToJSONOptions): IMapField;
 
     /**
      * Map field decorator (TypeScript).
@@ -568,9 +512,8 @@ 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.
      */
-    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;
+    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;
 }
 
 /** Map field descriptor. */
@@ -596,21 +539,18 @@ export class Message<T extends object = object> {
      */
     constructor(properties?: Properties<T>);
 
-    /** Unknown fields preserved while decoding when enabled */
-    $unknowns?: Uint8Array[];
-
     /** Reference to the reflected type. */
-    static readonly $type: Type;
+    public static readonly $type: Type;
 
     /** Reference to the reflected type. */
-    readonly $type: Type;
+    public readonly $type: Type;
 
     /**
      * Creates a new message of this type using the specified properties.
      * @param [properties] Properties to set
      * @returns Message instance
      */
-    static create<T extends Message<T>>(this: Constructor<T>, properties?: { [k: string]: any }): T;
+    public static create<T extends Message<T>>(this: Constructor<T>, properties?: { [k: string]: any }): Message<T>;
 
     /**
      * Encodes a message of this type.
@@ -618,7 +558,7 @@ export class Message<T extends object = object> {
      * @param [writer] Writer to use
      * @returns Writer
      */
-    static encode<T extends Message<T>>(this: Constructor<T>, message: (T|{ [k: string]: any }), writer?: Writer): Writer;
+    public static encode<T extends Message<T>>(this: Constructor<T>, message: (T|{ [k: string]: any }), writer?: Writer): Writer;
 
     /**
      * Encodes a message of this type preceeded by its length as a varint.
@@ -626,35 +566,35 @@ export class Message<T extends object = object> {
      * @param [writer] Writer to use
      * @returns Writer
      */
-    static encodeDelimited<T extends Message<T>>(this: Constructor<T>, message: (T|{ [k: string]: any }), writer?: Writer): Writer;
+    public static encodeDelimited<T extends Message<T>>(this: Constructor<T>, message: (T|{ [k: string]: any }), writer?: Writer): Writer;
 
     /**
      * Decodes a message of this type.
      * @param reader Reader or buffer to decode
      * @returns Decoded message
      */
-    static decode<T extends Message<T>>(this: Constructor<T>, reader: (Reader|Uint8Array)): T;
+    public static decode<T extends Message<T>>(this: Constructor<T>, reader: (Reader|Uint8Array)): T;
 
     /**
      * Decodes a message of this type preceeded by its length as a varint.
      * @param reader Reader or buffer to decode
      * @returns Decoded message
      */
-    static decodeDelimited<T extends Message<T>>(this: Constructor<T>, reader: (Reader|Uint8Array)): T;
+    public static decodeDelimited<T extends Message<T>>(this: Constructor<T>, reader: (Reader|Uint8Array)): T;
 
     /**
      * Verifies a message of this type.
      * @param message Plain object to verify
      * @returns `null` if valid, otherwise the reason why it is not
      */
-    static verify(message: { [k: string]: any }): (string|null);
+    public static verify(message: { [k: string]: any }): (string|null);
 
     /**
      * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
      * @param object Plain object
      * @returns Message instance
      */
-    static fromObject<T extends Message<T>>(this: Constructor<T>, object: { [k: string]: any }): T;
+    public static fromObject<T extends Message<T>>(this: Constructor<T>, object: { [k: string]: any }): T;
 
     /**
      * Creates a plain object from a message of this type. Also converts values to other types if specified.
@@ -662,13 +602,13 @@ export class Message<T extends object = object> {
      * @param [options] Conversion options
      * @returns Plain object
      */
-    static toObject<T extends Message<T>>(this: Constructor<T>, message: T, options?: IConversionOptions): { [k: string]: any };
+    public static toObject<T extends Message<T>>(this: Constructor<T>, message: T, options?: IConversionOptions): { [k: string]: any };
 
     /**
      * Converts this message to JSON.
      * @returns JSON object
      */
-    toJSON(): { [k: string]: any };
+    public toJSON(): { [k: string]: any };
 }
 
 /** Reflected service method. */
@@ -684,39 +624,36 @@ 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 objects
+     * @param [parsedOptions] Declared options, properly parsed into an object
      */
-    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. */
-    type: string;
+    public type: string;
 
     /** Request type. */
-    requestType: string;
+    public requestType: string;
 
     /** Whether requests are streamed or not. */
-    requestStream?: true;
+    public requestStream?: boolean;
 
     /** Response type. */
-    responseType: string;
+    public responseType: string;
 
     /** Whether responses are streamed or not. */
-    responseStream?: true;
-
-    /** gRPC-style method path. */
-    path: string;
+    public responseStream?: boolean;
 
     /** Resolved request type. */
-    resolvedRequestType: (Type|null);
+    public resolvedRequestType: (Type|null);
 
     /** Resolved response type. */
-    resolvedResponseType: (Type|null);
+    public resolvedResponseType: (Type|null);
 
     /** Comment for this method */
-    comment: (string|null);
+    public comment: (string|null);
 
-    /** Options properly parsed into objects */
-    parsedOptions?: { [k: string]: any }[];
+    /** Options properly parsed into an object */
+    public parsedOptions: any;
 
     /**
      * Constructs a method from a method descriptor.
@@ -725,14 +662,14 @@ export class Method extends ReflectionObject {
      * @returns Created method
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IMethod): Method;
+    public static fromJSON(name: string, json: IMethod): Method;
 
     /**
      * Converts this method to a method descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Method descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IMethod;
+    public toJSON(toJSONOptions?: IToJSONOptions): IMethod;
 }
 
 /** Method descriptor. */
@@ -756,11 +693,11 @@ export interface IMethod {
     /** Method options */
     options?: { [k: string]: any };
 
-    /** Method comment */
-    comment?: (string|null);
+    /** Method comments */
+    comment: string;
 
-    /** Method options properly parsed into objects */
-    parsedOptions?: { [k: string]: any }[];
+    /** Method options properly parsed into an object */
+    parsedOptions?: { [k: string]: any };
 }
 
 /** Reflected namespace. */
@@ -781,7 +718,7 @@ export class Namespace extends NamespaceBase {
      * @returns Created namespace
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: { [k: string]: any }, depth?: number): Namespace;
+    public static fromJSON(name: string, json: { [k: string]: any }, depth?: number): Namespace;
 
     /**
      * Converts an array of reflection objects to JSON.
@@ -789,7 +726,7 @@ export class Namespace extends NamespaceBase {
      * @param [toJSONOptions] JSON conversion options
      * @returns JSON object or `undefined` when array is empty
      */
-    static arrayToJSON(array: ReflectionObject[], toJSONOptions?: IToJSONOptions): ({ [k: string]: any }|undefined);
+    public static arrayToJSON(array: ReflectionObject[], toJSONOptions?: IToJSONOptions): ({ [k: string]: any }|undefined);
 
     /**
      * Tests if the specified id is reserved.
@@ -797,7 +734,7 @@ export class Namespace extends NamespaceBase {
      * @param id Id to test
      * @returns `true` if reserved, otherwise `false`
      */
-    static isReservedId(reserved: ((number[]|string)[]|undefined), id: number): boolean;
+    public static isReservedId(reserved: ((number[]|string)[]|undefined), id: number): boolean;
 
     /**
      * Tests if the specified name is reserved.
@@ -805,14 +742,14 @@ export class Namespace extends NamespaceBase {
      * @param name Name to test
      * @returns `true` if reserved, otherwise `false`
      */
-    static isReservedName(reserved: ((number[]|string)[]|undefined), name: string): boolean;
+    public static isReservedName(reserved: ((number[]|string)[]|undefined), name: string): boolean;
 }
 
 /** Base class of all reflection objects containing nested objects. This is not an actual class but here for the sake of having consistent type definitions. */
 export abstract class NamespaceBase extends ReflectionObject {
 
     /** Nested objects by name. */
-    nested?: { [k: string]: ReflectionObject };
+    public nested?: { [k: string]: ReflectionObject };
 
     /** Whether or not objects contained in this namespace need feature resolution. */
     protected _needsRecursiveFeatureResolution: boolean;
@@ -821,14 +758,14 @@ export abstract class NamespaceBase extends ReflectionObject {
     protected _needsRecursiveResolve: boolean;
 
     /** Nested objects of this namespace as an array for iteration. */
-    readonly nestedArray: ReflectionObject[];
+    public readonly nestedArray: ReflectionObject[];
 
     /**
      * Converts this namespace to a namespace descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Namespace descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): INamespace;
+    public toJSON(toJSONOptions?: IToJSONOptions): INamespace;
 
     /**
      * Adds nested objects to this namespace from nested object descriptors.
@@ -836,14 +773,14 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @param [depth] Current nesting depth, defaults to `0`
      * @returns `this`
      */
-    addJSON(nestedJson: { [k: string]: AnyNestedObject }, depth?: number): Namespace;
+    public addJSON(nestedJson: { [k: string]: AnyNestedObject }, depth?: number): Namespace;
 
     /**
      * Gets the nested object of the specified name.
      * @param name Nested object name
      * @returns The reflection object or `null` if it doesn't exist
      */
-    get(name: string): (ReflectionObject|null);
+    public get(name: string): (ReflectionObject|null);
 
     /**
      * Gets the values of the nested {@link Enum|enum} of the specified name.
@@ -852,7 +789,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @returns Enum values
      * @throws {Error} If there is no such enum
      */
-    getEnum(name: string): { [k: string]: number };
+    public getEnum(name: string): { [k: string]: number };
 
     /**
      * Adds a nested object to this namespace.
@@ -861,7 +798,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If there is already a nested object with this name
      */
-    add(object: ReflectionObject): Namespace;
+    public add(object: ReflectionObject): Namespace;
 
     /**
      * Removes a nested object from this namespace.
@@ -870,7 +807,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If `object` is not a member of this namespace
      */
-    remove(object: ReflectionObject): Namespace;
+    public remove(object: ReflectionObject): Namespace;
 
     /**
      * Defines additial namespaces within this one if not yet existing.
@@ -878,13 +815,13 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @param [json] Nested types to create from JSON
      * @returns Pointer to the last namespace created or `this` if path is empty
      */
-    define(path: (string|string[]), json?: any): Namespace;
+    public define(path: (string|string[]), json?: any): Namespace;
 
     /**
      * Resolves this namespace's and all its nested objects' type references. Useful to validate a reflection tree, but comes at a cost.
      * @returns `this`
      */
-    resolveAll(): Namespace;
+    public resolveAll(): Namespace;
 
     /**
      * Recursively looks up the reflection object matching the specified path in the scope of this namespace.
@@ -893,7 +830,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @param [parentAlreadyChecked=false] If known, whether the parent has already been checked
      * @returns Looked up object or `null` if none could be found
      */
-    lookup(path: (string|string[]), filterTypes: (any|any[]), parentAlreadyChecked?: boolean): (ReflectionObject|null);
+    public lookup(path: (string|string[]), filterTypes: (any|any[]), parentAlreadyChecked?: boolean): (ReflectionObject|null);
 
     /**
      * Looks up the reflection object at the specified path, relative to this namespace.
@@ -901,7 +838,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @param [parentAlreadyChecked=false] Whether the parent has already been checked
      * @returns Looked up object or `null` if none could be found
      */
-    lookup(path: (string|string[]), parentAlreadyChecked?: boolean): (ReflectionObject|null);
+    public lookup(path: (string|string[]), parentAlreadyChecked?: boolean): (ReflectionObject|null);
 
     /**
      * Looks up the {@link Type|type} at the specified path, relative to this namespace.
@@ -910,7 +847,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @returns Looked up type
      * @throws {Error} If `path` does not point to a type
      */
-    lookupType(path: (string|string[])): Type;
+    public lookupType(path: (string|string[])): Type;
 
     /**
      * Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.
@@ -919,7 +856,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @returns Looked up enum
      * @throws {Error} If `path` does not point to an enum
      */
-    lookupEnum(path: (string|string[])): Enum;
+    public lookupEnum(path: (string|string[])): Enum;
 
     /**
      * Looks up the {@link Type|type} or {@link Enum|enum} at the specified path, relative to this namespace.
@@ -928,7 +865,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @returns Looked up type or enum
      * @throws {Error} If `path` does not point to a type or enum
      */
-    lookupTypeOrEnum(path: (string|string[])): Type;
+    public lookupTypeOrEnum(path: (string|string[])): Type;
 
     /**
      * Looks up the {@link Service|service} at the specified path, relative to this namespace.
@@ -937,7 +874,7 @@ export abstract class NamespaceBase extends ReflectionObject {
      * @returns Looked up service
      * @throws {Error} If `path` does not point to a service
      */
-    lookupService(path: (string|string[])): Service;
+    public lookupService(path: (string|string[])): Service;
 }
 
 /** Namespace descriptor. */
@@ -951,77 +888,77 @@ export interface INamespace {
 }
 
 /** Any extension field descriptor. */
-export type AnyExtensionField = (IExtensionField|IExtensionMapField);
+type AnyExtensionField = (IExtensionField|IExtensionMapField);
 
 /** Any nested object descriptor. */
-export type AnyNestedObject = (IEnum|IType|IService|AnyExtensionField|INamespace|IOneOf);
+type AnyNestedObject = (IEnum|IType|IService|AnyExtensionField|INamespace|IOneOf);
 
 /** Base class of all reflection objects. */
 export abstract class ReflectionObject {
 
     /** Options. */
-    options?: { [k: string]: any };
+    public options?: { [k: string]: any };
 
     /** Parsed Options. */
-    parsedOptions?: { [k: string]: any }[];
+    public parsedOptions?: { [k: string]: any[] };
 
     /** Unique name within its namespace. */
-    name: string;
+    public name: string;
 
     /** Parent namespace. */
-    parent: (Namespace|null);
+    public parent: (Namespace|null);
 
     /** Whether already resolved or not. */
-    resolved: boolean;
+    public resolved: boolean;
 
     /** Comment text, if any. */
-    comment: (string|null);
+    public comment: (string|null);
 
     /** Defining file name. */
-    filename: (string|null);
+    public filename: (string|null);
 
     /** Reference to the root namespace. */
-    readonly root: Root;
+    public readonly root: Root;
 
     /** Full name including leading dot. */
-    readonly fullName: string;
+    public readonly fullName: string;
 
     /**
      * Converts this reflection object to its descriptor representation.
      * @returns Descriptor
      */
-    toJSON(): { [k: string]: any };
+    public toJSON(): { [k: string]: any };
 
     /**
      * Called when this object is added to a parent.
      * @param parent Parent added to
      */
-    onAdd(parent: ReflectionObject): void;
+    public onAdd(parent: ReflectionObject): void;
 
     /**
      * Called when this object is removed from a parent.
      * @param parent Parent removed from
      */
-    onRemove(parent: ReflectionObject): void;
+    public onRemove(parent: ReflectionObject): void;
 
     /**
      * Resolves this objects type references.
      * @returns `this`
      */
-    resolve(): ReflectionObject;
+    public resolve(): ReflectionObject;
 
     /**
      * Resolves this objects editions features.
      * @param edition The edition we're currently resolving for.
      * @returns `this`
      */
-    _resolveFeaturesRecursive(edition: string): ReflectionObject;
+    public _resolveFeaturesRecursive(edition: string): ReflectionObject;
 
     /**
      * Resolves child features from parent features
      * @param edition The edition we're currently resolving for.
      */
-    _resolveFeatures(edition: string): void;
+    public _resolveFeatures(edition: string): void;
 
     /**
      * Infers features from legacy syntax that may have been specified differently.
@@ -1029,14 +966,14 @@ export abstract class ReflectionObject {
      * @param edition The edition this proto is on, or undefined if pre-editions
      * @returns The feature values to override
      */
-    _inferLegacyProtoFeatures(edition: (string|undefined)): object;
+    public _inferLegacyProtoFeatures(edition: (string|undefined)): object;
 
     /**
      * Gets an option value.
      * @param name Option name
      * @returns Option value or `undefined` if not set
      */
-    getOption(name: string): any;
+    public getOption(name: string): any;
 
     /**
      * Sets an option.
@@ -1045,7 +982,7 @@ export abstract class ReflectionObject {
      * @param [ifNotSet] Sets the option only if it isn't currently set
      * @returns `this`
      */
-    setOption(name: string, value: any, ifNotSet?: (boolean|undefined)): ReflectionObject;
+    public setOption(name: string, value: any, ifNotSet?: (boolean|undefined)): ReflectionObject;
 
     /**
      * Sets a parsed option.
@@ -1054,7 +991,7 @@ export abstract class ReflectionObject {
      * @param propName dot '.' delimited full path of property within the option to set. if undefined\empty, will add a new option with that value
      * @returns `this`
      */
-    setParsedOption(name: string, value: any, propName: string): ReflectionObject;
+    public setParsedOption(name: string, value: any, propName: string): ReflectionObject;
 
     /**
      * Sets multiple options.
@@ -1062,19 +999,19 @@ export abstract class ReflectionObject {
      * @param [ifNotSet] Sets an option only if it isn't currently set
      * @returns `this`
      */
-    setOptions(options: { [k: string]: any }, ifNotSet?: boolean): ReflectionObject;
+    public setOptions(options: { [k: string]: any }, ifNotSet?: boolean): ReflectionObject;
 
     /**
      * Converts this instance to its string representation.
      * @returns Class name[, space, full name]
      */
-    toString(): string;
+    public toString(): string;
 
     /**
      * Converts the edition this object is pinned to for JSON format.
      * @returns The edition string for JSON representation
      */
-    _editionToJSON(): (string|undefined);
+    public _editionToJSON(): (string|undefined);
 }
 
 /** Reflected oneof. */
@@ -1090,13 +1027,13 @@ export class OneOf extends ReflectionObject {
     constructor(name: string, fieldNames?: (string[]|{ [k: string]: any }), options?: { [k: string]: any }, comment?: string);
 
     /** Field names that belong to this oneof. */
-    oneof: string[];
+    public oneof: string[];
 
     /** Fields that belong to this oneof as an array for iteration. */
-    readonly fieldsArray: Field[];
+    public readonly fieldsArray: Field[];
 
     /** Comment for this field. */
-    comment: (string|null);
+    public comment: (string|null);
 
     /**
      * Constructs a oneof from a oneof descriptor.
@@ -1105,43 +1042,42 @@ export class OneOf extends ReflectionObject {
      * @returns Created oneof
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IOneOf): OneOf;
+    public static fromJSON(name: string, json: IOneOf): OneOf;
 
     /**
      * Converts this oneof to a oneof descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Oneof descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IOneOf;
+    public toJSON(toJSONOptions?: IToJSONOptions): IOneOf;
 
     /**
      * Adds a field to this oneof and removes it from its current parent, if any.
      * @param field Field to add
      * @returns `this`
      */
-    add(field: Field): OneOf;
+    public add(field: Field): OneOf;
 
     /**
      * Removes a field from this oneof and puts it back to the oneof's parent.
      * @param field Field to remove
      * @returns `this`
      */
-    remove(field: Field): OneOf;
+    public remove(field: Field): OneOf;
 
     /**
      * Determines whether this field corresponds to a synthetic oneof created for
      * a proto3 optional field.  No behavioral logic should depend on this, but it
      * can be relevant for reflection.
      */
-    readonly isProto3Optional: boolean;
+    public readonly isProto3Optional: boolean;
 
     /**
      * OneOf decorator (TypeScript).
      * @param fieldNames Field names
      * @returns Decorator function
-     * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
      */
-    static d<T extends string>(...fieldNames: string[]): OneOfDecorator;
+    public static d<T extends string>(...fieldNames: string[]): OneOfDecorator;
 }
 
 /** Oneof descriptor. */
@@ -1152,18 +1088,14 @@ export interface IOneOf {
 
     /** Oneof options */
     options?: { [k: string]: any };
-
-    /** Oneof comment */
-    comment?: (string|null);
 }
 
 /**
  * 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.
  */
-export type OneOfDecorator = (prototype: object, oneofName: string) => void;
+type OneOfDecorator = (prototype: object, oneofName: string) => void;
 
 /**
  * Parses the given .proto source and returns an object with the parsed contents.
@@ -1218,7 +1150,7 @@ export interface IToJSONOptions {
  */
 export function parse(source: string, root: Root, options?: IParseOptions): IParserResult;
 
-/** Wire format reader using `Uint8Array`. */
+/** Wire format reader using `Uint8Array` if available, otherwise `Array`. */
 export class Reader {
 
     /**
@@ -1228,19 +1160,13 @@ export class Reader {
     constructor(buffer: Uint8Array);
 
     /** Read buffer. */
-    buf: Uint8Array;
+    public buf: Uint8Array;
 
     /** Read buffer position. */
-    pos: number;
+    public pos: number;
 
     /** Read buffer length. */
-    len: number;
-
-    /** Cached DataView for packed reads. */
-    view: (DataView|null);
-
-    /** Whether to discard unknown fields while decoding. */
-    discardUnknown: boolean;
+    public len: number;
 
     /**
      * Creates a new reader using the specified buffer.
@@ -1248,236 +1174,115 @@ export class Reader {
      * @returns A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
      * @throws {Error} If `buffer` is not a valid buffer
      */
-    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
-     */
-    raw(start: number, end: number): Uint8Array;
+    public static create(buffer: (Uint8Array|Buffer)): (Reader|BufferReader);
 
     /**
      * Reads a varint as an unsigned 32 bit value.
      * @returns Value read
      */
-    uint32(): number;
-
-    /**
-     * Reads a field tag.
-     * @returns Tag read
-     */
-    tag(): number;
-
-    /**
-     * Reads a varint length prefix within signed 32 bit range.
-     * @returns Length read
-     */
-    size(): number;
+    public uint32(): number;
 
     /**
      * Reads a varint as a signed 32 bit value.
      * @returns Value read
      */
-    int32(): number;
+    public int32(): number;
 
     /**
      * Reads a zig-zag encoded varint as a signed 32 bit value.
      * @returns Value read
      */
-    sint32(): number;
+    public sint32(): number;
 
     /**
      * Reads a varint as a signed 64 bit value.
      * @returns Value read
      */
-    int64(): Long;
+    public int64(): Long;
 
     /**
      * Reads a varint as an unsigned 64 bit value.
      * @returns Value read
      */
-    uint64(): Long;
+    public uint64(): Long;
 
     /**
      * Reads a zig-zag encoded varint as a signed 64 bit value.
      * @returns Value read
      */
-    sint64(): Long;
+    public sint64(): Long;
 
     /**
      * Reads a varint as a boolean.
      * @returns Value read
      */
-    bool(): boolean;
+    public bool(): boolean;
 
     /**
      * Reads fixed 32 bits as an unsigned 32 bit integer.
      * @returns Value read
      */
-    fixed32(): number;
+    public fixed32(): number;
 
     /**
      * Reads fixed 32 bits as a signed 32 bit integer.
      * @returns Value read
      */
-    sfixed32(): number;
+    public sfixed32(): number;
 
     /**
      * Reads fixed 64 bits.
      * @returns Value read
      */
-    fixed64(): Long;
+    public fixed64(): Long;
 
     /**
      * Reads zig-zag encoded fixed 64 bits.
      * @returns Value read
      */
-    sfixed64(): Long;
+    public sfixed64(): Long;
 
     /**
      * Reads a float (32 bit) as a number.
      * @returns Value read
      */
-    float(): number;
+    public float(): number;
 
     /**
      * Reads a double (64 bit float) as a number.
      * @returns Value read
      */
-    double(): number;
-
-    /**
-     * Reads a packed repeated field of unsigned 32 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    uint32s(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of signed 32 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    int32s(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of zig-zag encoded signed 32 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    sint32s(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of booleans.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    bools(array?: boolean[]): boolean[];
-
-    /**
-     * Reads a packed repeated field of unsigned 32 bit fixed values.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    fixed32s(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of signed 32 bit fixed values.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    sfixed32s(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of floats (32 bit).
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    floats(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of doubles (64 bit float).
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    doubles(array?: number[]): number[];
-
-    /**
-     * Reads a packed repeated field of unsigned 64 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    uint64s(array?: (Long|number)[]): (Long|number)[];
-
-    /**
-     * Reads a packed repeated field of signed 64 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    int64s(array?: (Long|number)[]): (Long|number)[];
-
-    /**
-     * Reads a packed repeated field of zig-zag encoded signed 64 bit varints.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    sint64s(array?: (Long|number)[]): (Long|number)[];
-
-    /**
-     * Reads a packed repeated field of unsigned 64 bit fixed values.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    fixed64s(array?: (Long|number)[]): (Long|number)[];
-
-    /**
-     * Reads a packed repeated field of signed 64 bit fixed values.
-     * @param [array] Array to read into; a new one is created if omitted
-     * @returns Array read into
-     */
-    sfixed64s(array?: (Long|number)[]): (Long|number)[];
+    public double(): number;
 
     /**
      * Reads a sequence of bytes preceeded by its length as a varint.
      * @returns Value read
      */
-    bytes(): Uint8Array;
+    public bytes(): Uint8Array;
 
     /**
      * Reads a string preceeded by its byte length as a varint.
      * @returns Value read
      */
-    string(): string;
-
-    /**
-     * Reads a string preceeded by its byte length as a varint, rejecting invalid UTF8.
-     * @returns Value read
-     */
-    stringVerify(): string;
+    public string(): string;
 
     /**
      * Skips the specified number of bytes if specified, otherwise skips a varint.
      * @param [length] Length if known, otherwise a varint is assumed
      * @returns `this`
      */
-    skip(length?: number): Reader;
+    public skip(length?: number): Reader;
 
     /** Recursion limit. */
-    static recursionLimit: number;
-
-    /** Whether readers discard unknown fields while decoding. */
-    static discardUnknown: boolean;
+    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`
      */
-    skipType(wireType: number, depth?: number, fieldNumber?: number): Reader;
+    public skipType(wireType: number, depth?: number): Reader;
 }
 
 /** Wire format reader using node buffers. */
@@ -1489,19 +1294,11 @@ 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
-     */
-    raw(start: number, end: number): Buffer;
-
     /**
      * Reads a sequence of bytes preceeded by its length as a varint.
      * @returns Value read
      */
-    bytes(): Buffer;
+    public bytes(): Buffer;
 }
 
 /** Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together. */
@@ -1514,10 +1311,10 @@ export class Root extends NamespaceBase {
     constructor(options?: { [k: string]: any });
 
     /** Deferred extension fields. */
-    deferred: Field[];
+    public deferred: Field[];
 
     /** Resolved file names of loaded files. */
-    files: string[];
+    public files: string[];
 
     /**
      * Loads a namespace descriptor into a root namespace.
@@ -1526,7 +1323,7 @@ export class Root extends NamespaceBase {
      * @param [depth] Current nesting depth, defaults to `0`
      * @returns Root namespace
      */
-    static fromJSON(json: INamespace, root?: Root, depth?: number): Root;
+    public static fromJSON(json: INamespace, root?: Root, depth?: number): Root;
 
     /**
      * Resolves the path of an imported file, relative to the importing origin.
@@ -1535,7 +1332,7 @@ export class Root extends NamespaceBase {
      * @param target The file name being imported
      * @returns Resolved path to `target` or `null` to skip the file
      */
-    resolvePath(origin: string, target: string): (string|null);
+    public resolvePath(origin: string, target: string): (string|null);
 
     /**
      * Fetch content from file path or url
@@ -1543,7 +1340,7 @@ export class Root extends NamespaceBase {
      * @param path File path or url
      * @param callback Callback function
      */
-    fetch(path: string, callback: FetchCallback): void;
+    public fetch(path: string, callback: FetchCallback): void;
 
     /**
      * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
@@ -1551,14 +1348,14 @@ export class Root extends NamespaceBase {
      * @param options Parse options
      * @param callback Callback function
      */
-    load(filename: (string|string[]), options: IParseOptions, callback: LoadCallback): void;
+    public load(filename: (string|string[]), options: IParseOptions, callback: LoadCallback): void;
 
     /**
      * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
      * @param filename Names of one or multiple files to load
      * @param callback Callback function
      */
-    load(filename: (string|string[]), callback: LoadCallback): void;
+    public load(filename: (string|string[]), callback: LoadCallback): void;
 
     /**
      * Loads one or multiple .proto or preprocessed .json files into this root namespace and returns a promise.
@@ -1566,7 +1363,7 @@ export class Root extends NamespaceBase {
      * @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
      * @returns Promise
      */
-    load(filename: (string|string[]), options?: IParseOptions): Promise<Root>;
+    public load(filename: (string|string[]), options?: IParseOptions): Promise<Root>;
 
     /**
      * Synchronously loads one or multiple .proto or preprocessed .json files into this root namespace (node only).
@@ -1575,7 +1372,7 @@ export class Root extends NamespaceBase {
      * @returns Root namespace
      * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
      */
-    loadSync(filename: (string|string[]), options?: IParseOptions): Root;
+    public loadSync(filename: (string|string[]), options?: IParseOptions): Root;
 }
 
 /**
@@ -1597,17 +1394,13 @@ export namespace rpc {
      */
     type ServiceMethodCallback<TRes extends Message<TRes>> = (error: (Error|null), response?: TRes) => void;
 
-    /** A service method part of a {@link rpc.Service} as created by {@link Service.create}. */
-    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = {
-      (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
-      (request: TReq|Properties<TReq>): Promise<TRes>;
-      readonly name: string;
-      readonly path: string;
-      readonly requestType: string;
-      readonly responseType: string;
-      readonly requestStream: true|undefined;
-      readonly responseStream: true|undefined;
-    };
+    /**
+     * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
+     * @param request Request message or plain object
+     * @param [callback] Node-style callback called with the error, if any, and the response message
+     * @returns Promise if `callback` has been omitted, otherwise `undefined`
+     */
+    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = (request: (TReq|Properties<TReq>), callback?: rpc.ServiceMethodCallback<TRes>) => Promise<Message<TRes>>;
 
     /** An RPC service as returned by {@link Service#create}. */
     class Service extends util.EventEmitter {
@@ -1621,13 +1414,13 @@ export namespace rpc {
         constructor(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
 
         /** RPC implementation. Becomes `null` once the service is ended. */
-        rpcImpl: (RPCImpl|null);
+        public rpcImpl: (RPCImpl|null);
 
         /** Whether requests are length-delimited. */
-        requestDelimited: boolean;
+        public requestDelimited: boolean;
 
         /** Whether responses are length-delimited. */
-        responseDelimited: boolean;
+        public responseDelimited: boolean;
 
         /**
          * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
@@ -1637,14 +1430,14 @@ export namespace rpc {
          * @param request Request message or plain object
          * @param callback Service callback
          */
-        rpcCall<TReq extends Message<TReq>, TRes extends Message<TRes>>(method: (Method|rpc.ServiceMethod<TReq, TRes>), requestCtor: Constructor<TReq>, responseCtor: Constructor<TRes>, request: (TReq|Properties<TReq>), callback: rpc.ServiceMethodCallback<TRes>): void;
+        public rpcCall<TReq extends Message<TReq>, TRes extends Message<TRes>>(method: (Method|rpc.ServiceMethod<TReq, TRes>), requestCtor: Constructor<TReq>, responseCtor: Constructor<TRes>, request: (TReq|Properties<TReq>), callback: rpc.ServiceMethodCallback<TRes>): void;
 
         /**
          * Ends this service and emits the `end` event.
          * @param [endedByRPC=false] Whether the service has been ended by the RPC implementation.
          * @returns `this`
          */
-        end(endedByRPC?: boolean): rpc.Service;
+        public end(endedByRPC?: boolean): rpc.Service;
     }
 }
 
@@ -1654,14 +1447,14 @@ export namespace rpc {
  * @param requestData Request data
  * @param callback Callback function
  */
-export type RPCImpl = (method: (Method|rpc.ServiceMethod<Message<{}>, Message<{}>>), requestData: Uint8Array, callback: RPCImplCallback) => void;
+type RPCImpl = (method: (Method|rpc.ServiceMethod<Message<{}>, Message<{}>>), requestData: Uint8Array, callback: RPCImplCallback) => void;
 
 /**
  * Node-style callback as used by {@link RPCImpl}.
  * @param error Error, if any, otherwise `null`
  * @param [response] Response data or `null` to signal end of stream, if there hasn't been an error
  */
-export type RPCImplCallback = (error: (Error|null), response?: (Uint8Array|null)) => void;
+type RPCImplCallback = (error: (Error|null), response?: (Uint8Array|null)) => void;
 
 /** Reflected service. */
 export class Service extends NamespaceBase {
@@ -1675,7 +1468,7 @@ export class Service extends NamespaceBase {
     constructor(name: string, options?: { [k: string]: any });
 
     /** Service methods. */
-    methods: { [k: string]: Method };
+    public methods: { [k: string]: Method };
 
     /**
      * Constructs a service from a service descriptor.
@@ -1685,17 +1478,17 @@ export class Service extends NamespaceBase {
      * @returns Created service
      * @throws {TypeError} If arguments are invalid
      */
-    static fromJSON(name: string, json: IService, depth?: number): Service;
+    public static fromJSON(name: string, json: IService, depth?: number): Service;
 
     /**
      * Converts this service to a service descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Service descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IService;
+    public toJSON(toJSONOptions?: IToJSONOptions): IService;
 
     /** Methods of this service as an array for iteration. */
-    readonly methodsArray: Method[];
+    public readonly methodsArray: Method[];
 
     /**
      * Creates a runtime service using the specified rpc implementation.
@@ -1704,39 +1497,33 @@ export class Service extends NamespaceBase {
      * @param [responseDelimited=false] Whether responses are length-delimited
      * @returns RPC service. Useful where requests and/or responses are streamed.
      */
-    create(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean): rpc.Service;
+    public create(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean): rpc.Service;
 }
 
 /** Service descriptor. */
 export interface IService extends INamespace {
 
-    /** Edition */
-    edition?: string;
-
     /** Method descriptors */
     methods: { [k: string]: IMethod };
-
-    /** Service comment */
-    comment?: (string|null);
 }
 
 /**
  * Gets the next token and advances.
  * @returns Next token or `null` on eof
  */
-export type TokenizerHandleNext = () => (string|null);
+type TokenizerHandleNext = () => (string|null);
 
 /**
  * Peeks for the next token.
  * @returns Next token or `null` on eof
  */
-export type TokenizerHandlePeek = () => (string|null);
+type TokenizerHandlePeek = () => (string|null);
 
 /**
  * Pushes a token back to the stack.
  * @param token Token
  */
-export type TokenizerHandlePush = (token: string) => void;
+type TokenizerHandlePush = (token: string) => void;
 
 /**
  * Skips the next token.
@@ -1745,14 +1532,14 @@ export type TokenizerHandlePush = (token: string) => void;
  * @returns Whether the token matched
  * @throws {Error} If the token didn't match and is not optional
  */
-export type TokenizerHandleSkip = (expected: string, optional?: boolean) => boolean;
+type TokenizerHandleSkip = (expected: string, optional?: boolean) => boolean;
 
 /**
  * Gets the comment on the previous line or, alternatively, the line comment on the specified line.
  * @param [line] Line number
  * @returns Comment text or `null` if none
  */
-export type TokenizerHandleCmnt = (line?: number) => (string|null);
+type TokenizerHandleCmnt = (line?: number) => (string|null);
 
 /** Handle object returned from {@link tokenize}. */
 export interface ITokenizerHandle {
@@ -1805,42 +1592,38 @@ export class Type extends NamespaceBase {
     constructor(name: string, options?: { [k: string]: any });
 
     /** Message fields. */
-    fields: { [k: string]: Field };
+    public fields: { [k: string]: Field };
 
     /** Oneofs declared within this namespace, if any. */
-    oneofs: { [k: string]: OneOf };
+    public oneofs: { [k: string]: OneOf };
 
     /** Extension ranges, if any. */
-    extensions: number[][];
+    public extensions: number[][];
 
     /** Reserved ranges, if any. */
-    reserved: (number[]|string)[];
-
-    /** Declared symbol visibility, if any. */
-    visibility?: ("local"|"export");
+    public reserved: (number[]|string)[];
 
     /** Message fields by id. */
-    readonly fieldsById: { [k: number]: Field };
+    public readonly fieldsById: { [k: number]: Field };
 
     /** Fields of this message as an array for iteration. */
-    readonly fieldsArray: Field[];
+    public readonly fieldsArray: Field[];
 
     /** Oneofs of this message as an array for iteration. */
-    readonly oneofsArray: OneOf[];
+    public readonly oneofsArray: OneOf[];
 
     /**
      * The registered constructor, if any registered, otherwise a generic constructor.
      * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
-     * When assigning manually, add the type to its parent namespace/root first if fields reference other reflected types, because constructor setup resolves field defaults.
      */
-    ctor: Constructor<{}>;
+    public ctor: Constructor<{}>;
 
     /**
      * Generates a constructor function for the specified type.
      * @param mtype Message type
      * @returns Codegen instance
      */
-    static generateConstructor(mtype: Type): Codegen;
+    public static generateConstructor(mtype: Type): Codegen;
 
     /**
      * Creates a message type from a message type descriptor.
@@ -1849,14 +1632,14 @@ export class Type extends NamespaceBase {
      * @param [depth] Current nesting depth, defaults to `0`
      * @returns Created message type
      */
-    static fromJSON(name: string, json: IType, depth?: number): Type;
+    public static fromJSON(name: string, json: IType, depth?: number): Type;
 
     /**
      * Converts this message type to a message type descriptor.
      * @param [toJSONOptions] JSON conversion options
      * @returns Message type descriptor
      */
-    toJSON(toJSONOptions?: IToJSONOptions): IType;
+    public toJSON(toJSONOptions?: IToJSONOptions): IType;
 
     /**
      * Adds a nested object to this type.
@@ -1865,7 +1648,7 @@ export class Type extends NamespaceBase {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If there is already a nested object with this name or, if a field, when there is already a field with this id
      */
-    add(object: ReflectionObject): Type;
+    public add(object: ReflectionObject): Type;
 
     /**
      * Removes a nested object from this type.
@@ -1874,34 +1657,34 @@ export class Type extends NamespaceBase {
      * @throws {TypeError} If arguments are invalid
      * @throws {Error} If `object` is not a member of this type
      */
-    remove(object: ReflectionObject): Type;
+    public remove(object: ReflectionObject): Type;
 
     /**
      * Tests if the specified id is reserved.
      * @param id Id to test
      * @returns `true` if reserved, otherwise `false`
      */
-    isReservedId(id: number): boolean;
+    public isReservedId(id: number): boolean;
 
     /**
      * Tests if the specified name is reserved.
      * @param name Name to test
      * @returns `true` if reserved, otherwise `false`
      */
-    isReservedName(name: string): boolean;
+    public isReservedName(name: string): boolean;
 
     /**
      * Creates a new message of this type using the specified properties.
      * @param [properties] Properties to set
      * @returns Message instance
      */
-    create(properties?: { [k: string]: any }): ReflectedMessage;
+    public create(properties?: { [k: string]: any }): Message<{}>;
 
     /**
      * Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.
      * @returns `this`
      */
-    setup(): Type;
+    public setup(): Type;
 
     /**
      * Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.
@@ -1909,7 +1692,7 @@ export class Type extends NamespaceBase {
      * @param [writer] Writer to encode to
      * @returns writer
      */
-    encode(message: (Message<{}>|{ [k: string]: any }), writer?: Writer): Writer;
+    public encode(message: (Message<{}>|{ [k: string]: any }), writer?: Writer): Writer;
 
     /**
      * Encodes a message of this type preceeded by its byte length as a varint. Does not implicitly {@link Type#verify|verify} messages.
@@ -1917,17 +1700,19 @@ export class Type extends NamespaceBase {
      * @param [writer] Writer to encode to
      * @returns writer
      */
-    encodeDelimited(message: (Message<{}>|{ [k: string]: any }), writer?: Writer): Writer;
+    public encodeDelimited(message: (Message<{}>|{ [k: string]: any }), writer?: Writer): Writer;
 
     /**
      * Decodes a message of this type.
      * @param reader Reader or buffer to decode from
      * @param [length] Length of the message, if known beforehand
+     * @param [end] Expected group end tag, if decoding a group
+     * @param [depth] Current nesting depth
      * @returns Decoded message
      * @throws {Error} If the payload is not a reader or valid buffer
      * @throws {util.ProtocolError<{}>} If required fields are missing
      */
-    decode(reader: (Reader|Uint8Array), length?: number): ReflectedMessage;
+    public decode(reader: (Reader|Uint8Array), length?: number, end?: number, depth?: number): Message<{}>;
 
     /**
      * Decodes a message of this type preceeded by its byte length as a varint.
@@ -1936,21 +1721,23 @@ export class Type extends NamespaceBase {
      * @throws {Error} If the payload is not a reader or valid buffer
      * @throws {util.ProtocolError} If required fields are missing
      */
-    decodeDelimited(reader: (Reader|Uint8Array)): ReflectedMessage;
+    public decodeDelimited(reader: (Reader|Uint8Array)): Message<{}>;
 
     /**
      * Verifies that field values are valid and that required fields are present.
      * @param message Plain object to verify
+     * @param [depth] Current nesting depth
      * @returns `null` if valid, otherwise the reason why it is not
      */
-    verify(message: { [k: string]: any }): (null|string);
+    public verify(message: { [k: string]: any }, depth?: number): (null|string);
 
     /**
      * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
      * @param object Plain object to convert
+     * @param [depth] Current nesting depth
      * @returns Message instance
      */
-    fromObject(object: { [k: string]: any }): ReflectedMessage;
+    public fromObject(object: { [k: string]: any }, depth?: number): Message<{}>;
 
     /**
      * Creates a plain object from a message of this type. Also converts values to other types if specified.
@@ -1958,30 +1745,19 @@ export class Type extends NamespaceBase {
      * @param [options] Conversion options
      * @returns Plain object
      */
-    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
-     */
-    getTypeUrl(prefix?: string): string;
+    public toObject(message: Message<{}>, options?: IConversionOptions): { [k: string]: any };
 
     /**
      * 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.
      */
-    static d<T extends Message<T>>(typeName?: string): TypeDecorator<T>;
+    public static d<T extends Message<T>>(typeName?: string): TypeDecorator<T>;
 }
 
 /** Message type descriptor. */
 export interface IType extends INamespace {
 
-    /** Edition */
-    edition?: string;
-
     /** Oneof descriptors */
     oneofs?: { [k: string]: IOneOf };
 
@@ -1996,12 +1772,6 @@ export interface IType extends INamespace {
 
     /** Whether a legacy group or not */
     group?: boolean;
-
-    /** Declared symbol visibility */
-    visibility?: ("local"|"export");
-
-    /** Message type comment */
-    comment?: (string|null);
 }
 
 /** Conversion options as used by {@link Type#toObject} and {@link Message.toObject}. */
@@ -2047,9 +1817,8 @@ 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.
  */
-export type TypeDecorator<T extends Message<T>> = (target: Constructor<T>) => void;
+type TypeDecorator<T extends Message<T>> = (target: Constructor<T>) => void;
 
 /** Common type constants. */
 export namespace types {
@@ -2137,52 +1906,12 @@ export namespace types {
 }
 
 /** Constructor type. */
-export type Constructor<T> = Function & { new(...params: any[]): T; prototype: T };
+export interface Constructor<T> extends Function {
+    new(...params: any[]): T; prototype: T;
+}
 
 /** Properties type. */
-export type Properties<T> = { [P in keyof T]?: T[P] };
-
-/** Dynamically reflected message type. */
-export type ReflectedMessage = Message<{}> & { [k: string]: any };
-
-/**
- * Callback as used by {@link util.asPromise}.
- * @param error Error, if any
- * @param params Additional arguments
- */
-export 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
- */
-export type Codegen = (formatStringOrScope?: (string|{ [k: string]: any }), ...formatParams: any[]) => (Codegen|Function);
-
-/**
- * Event listener as used by {@link util.EventEmitter}.
- * @param args Arguments
- */
-export 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
- */
-export 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;
-}
+type Properties<T> = { [P in keyof T]?: T[P] };
 
 /**
  * Any compatible Buffer instance.
@@ -2211,302 +1940,97 @@ export interface Long {
  * A OneOf getter as returned by {@link util.oneOfGetter}.
  * @returns Set field name, if any
  */
-export type OneOfGetter = () => (string|undefined);
+type OneOfGetter = () => (string|undefined);
 
 /**
  * A OneOf setter as returned by {@link util.oneOfSetter}.
  * @param value Field name
  */
-export type OneOfSetter = (value: (string|undefined)) => void;
-
-/**
- * An allocator as used by {@link util.pool}.
- * @param size Buffer size
- * @returns Buffer
- */
-export type PoolAllocator = (size: number) => Uint8Array;
-
-/**
- * A slicer as used by {@link util.pool}.
- * @param start Start offset
- * @param end End offset
- * @returns Buffer slice
- */
-export type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
+type OneOfSetter = (value: (string|undefined)) => void;
 
 /** Various utility functions. */
 export namespace util {
 
-    /**
-     * 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>;
+    /** Helper class for working with the low and high bits of a 64 bit value. */
+    class LongBits {
 
-    /** A minimal base64 implementation for number arrays. */
-    namespace base64 {
+        /**
+         * Constructs new long bits.
+         * @param lo Low 32 bits, unsigned
+         * @param hi High 32 bits, unsigned
+         */
+        constructor(lo: number, hi: number);
+
+        /** Low bits. */
+        public lo: number;
+
+        /** High bits. */
+        public hi: number;
+
+        /** Zero bits. */
+        public static zero: util.LongBits;
+
+        /** Zero hash. */
+        public static zeroHash: string;
 
         /**
-         * Calculates the byte length of a base64 encoded string.
-         * @param string Base64 encoded string
-         * @returns Byte length
+         * Constructs new long bits from the specified number.
+         * @param value Value
+         * @returns Instance
          */
-        function length(string: string): number;
+        public static fromNumber(value: number): util.LongBits;
 
         /**
-         * Encodes a buffer to a base64 encoded string.
-         * @param buffer Source buffer
-         * @param start Source start
-         * @param end Source end
-         * @returns Base64 encoded string
+         * Constructs new long bits from a number, long or string.
+         * @param value Value
+         * @returns Instance
          */
-        function encode(buffer: Uint8Array, start: number, end: number): string;
+        public static from(value: (Long|number|string)): util.LongBits;
 
         /**
-         * 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
+         * Converts this long bits to a possibly unsafe JavaScript number.
+         * @param [unsigned=false] Whether unsigned or not
+         * @returns Possibly unsafe number
          */
-        function decode(string: string, buffer: Uint8Array, offset: number): number;
+        public toNumber(unsigned?: boolean): number;
 
         /**
-         * Tests if the specified string appears to be base64 encoded.
-         * @param string String to test
-         * @returns `true` if probably base64 encoded, otherwise false
+         * Converts this long bits to a long.
+         * @param [unsigned=false] Whether unsigned or not
+         * @returns Long
          */
-        function test(string: string): boolean;
-    }
+        public toLong(unsigned?: boolean): Long;
 
-    /**
-     * 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;
+        /**
+         * Constructs new long bits from the specified 8 characters long hash.
+         * @param hash Hash
+         * @returns Bits
+         */
+        public static fromHash(hash: string): util.LongBits;
 
-    namespace codegen {
+        /**
+         * Converts this long bits to a 8 characters long hash.
+         * @returns Hash
+         */
+        public toHash(): string;
 
-        /** 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();
-
-        /**
-         * Registers an event listener.
-         * @param evt Event name
-         * @param fn Listener
-         * @param [ctx] Listener context
-         * @returns `this`
-         */
-        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`
-         */
-        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`
-         */
-        emit(evt: string, ...args: any[]): this;
-    }
-
-    /**
-     * 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;
-
-    /**
-     * Fetches the contents of a file.
-     * @param path File path or url
-     * @param callback Callback function
-     */
-    function fetch(path: string, callback: FetchCallback): void;
-
-    /**
-     * Fetches the contents of a file.
-     * @param path File path or url
-     * @param [options] Fetch options
-     * @returns Promise
-     */
-    function fetch(path: string, options?: IFetchOptions): Promise<(string|Uint8Array)>;
-
-    /** Reads / writes floats / doubles from / to buffers. */
-    namespace float {
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-
-        /**
-         * 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;
-    }
-
-    /** 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);
-
-        /** Low bits. */
-        lo: number;
-
-        /** High bits. */
-        hi: number;
-
-        /** Zero bits. */
-        static zero: util.LongBits;
-
-        /** Zero hash. */
-        static zeroHash: string;
-
-        /**
-         * Constructs new long bits from the specified number.
-         * @param value Value
-         * @returns Instance
-         */
-        static fromNumber(value: number): util.LongBits;
-
-        /**
-         * Constructs new long bits from a number, long or string.
-         * @param value Value
-         * @returns Instance
-         */
-        static from(value: (Long|number|string)): util.LongBits;
-
-        /**
-         * Converts this long bits to a possibly unsafe JavaScript number.
-         * @param [unsigned=false] Whether unsigned or not
-         * @returns Possibly unsafe number
-         */
-        toNumber(unsigned?: boolean): number;
-
-        /**
-         * Converts this long bits to a long.
-         * @param [unsigned=false] Whether unsigned or not
-         * @returns Long
-         */
-        toLong(unsigned?: boolean): Long;
-
-        /**
-         * Constructs new long bits from the specified 8 characters long hash.
-         * @param hash Hash
-         * @returns Bits
-         */
-        static fromHash(hash: string): util.LongBits;
-
-        /**
-         * Converts this long bits to a 8 characters long hash.
-         * @returns Hash
-         */
-        toHash(): string;
-
-        /**
-         * Zig-zag encodes this long bits.
-         * @returns `this`
-         */
-        zzEncode(): util.LongBits;
+        /**
+         * Zig-zag encodes this long bits.
+         * @returns `this`
+         */
+        public zzEncode(): util.LongBits;
 
         /**
          * Zig-zag decodes this long bits.
          * @returns `this`
          */
-        zzDecode(): util.LongBits;
+        public zzDecode(): util.LongBits;
 
         /**
          * Calculates the length of this longbits when encoded as a varint.
          * @returns Length
          */
-        length(): number;
+        public length(): number;
     }
 
     /**
@@ -2576,10 +2100,7 @@ export namespace util {
      */
     function newBuffer(sizeOrArray?: (number|number[])): (Uint8Array|Buffer);
 
-    /**
-     * Array implementation used in the browser.
-     * @deprecated Use `Uint8Array` instead.
-     */
+    /** Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`. */
     let Array: Constructor<Uint8Array>;
 
     /** Long.js's Long class if available. */
@@ -2609,21 +2130,6 @@ export namespace util {
      */
     function longFromHash(hash: string, unsigned?: boolean): (Long|number);
 
-    /**
-     * 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);
-
-    /**
-     * Converts a boolean key to a boolean value.
-     * @param key Map key
-     * @returns Boolean value
-     */
-    function boolFromKey(key: string): boolean;
-
     /**
      * Merges the properties of the source object into the destination object.
      * @param dst Destination object
@@ -2642,9 +2148,8 @@ export namespace util {
      * 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;
+    function makeProp(obj: { [k: string]: any }, key: string): void;
 
     /**
      * Converts the first character of a string to lower case.
@@ -2664,46 +2169,325 @@ export namespace util {
     class ProtocolError<T extends Message<T>> extends Error {
 
         /**
-         * Constructs a new protocol error.
-         * @param message Error message
-         * @param [properties] Additional properties
+         * Constructs a new protocol error.
+         * @param message Error message
+         * @param [properties] Additional properties
+         */
+        constructor(message: string, properties?: { [k: string]: any });
+
+        /** So far decoded message instance. */
+        public instance: Message<T>;
+    }
+
+    /**
+     * Builds a getter for a oneof's present field name.
+     * @param fieldNames Field names
+     * @returns Unbound getter
+     */
+    function oneOfGetter(fieldNames: string[]): OneOfGetter;
+
+    /**
+     * Builds a setter for a oneof's present field name.
+     * @param fieldNames Field names
+     * @returns Unbound setter
+     */
+    function oneOfSetter(fieldNames: string[]): OneOfSetter;
+
+    /**
+     * 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;
+
+    /** 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
+     */
+    function decorateType<T extends Message<T>>(ctor: Constructor<T>, typeName?: string): Type;
+
+    /**
+     * Decorator helper for enums (TypeScript).
+     * @param object Enum object
+     * @returns Reflected enum
+     */
+    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). */
+    let decorateRoot: Root;
+
+    /**
+     * 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>;
+
+    /** A minimal base64 implementation for number arrays. */
+    namespace base64 {
+
+        /**
+         * Calculates the byte length of a base64 encoded string.
+         * @param string Base64 encoded string
+         * @returns Byte length
+         */
+        function length(string: string): number;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+    }
+
+    /**
+     * 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;
+
+    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();
+
+        /**
+         * 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;
+    }
+
+    /** Reads / writes floats / doubles from / to buffers. */
+    namespace float {
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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;
+
+        /**
+         * 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
          */
-        constructor(message: string, properties?: { [k: string]: any });
-
-        /** So far decoded message instance. */
-        instance: Message<T>;
+        function readDoubleBE(buf: Uint8Array, pos: number): number;
     }
 
     /**
-     * Builds a getter for a oneof's present field name.
-     * @param fieldNames Field names
-     * @returns Unbound getter
+     * Fetches the contents of a file.
+     * @param filename File path or url
+     * @param options Fetch options
+     * @param callback Callback function
      */
-    function oneOfGetter(fieldNames: string[]): OneOfGetter;
+    function fetch(filename: string, options: IFetchOptions, callback: FetchCallback): void;
 
     /**
-     * Builds a setter for a oneof's present field name.
-     * @param fieldNames Field names
-     * @returns Unbound setter
+     * Fetches the contents of a file.
+     * @param path File path or url
+     * @param callback Callback function
      */
-    function oneOfSetter(fieldNames: string[]): OneOfSetter;
+    function fetch(path: string, callback: FetchCallback): void;
 
     /**
-     * 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
+     * Fetches the contents of a file.
+     * @param path File path or url
+     * @param [options] Fetch options
+     * @returns Promise
      */
-    let toJSONOptions: IConversionOptions;
+    function fetch(path: string, options?: IFetchOptions): Promise<(string|Uint8Array)>;
 
     /** A minimal path module to resolve Unix, Windows and URL paths alike. */
     namespace path {
@@ -2741,7 +2525,7 @@ export namespace util {
      */
     function pool(alloc: PoolAllocator, slice: PoolSlicer, size?: number): PoolAllocator;
 
-    /** A minimal UTF8 implementation. */
+    /** A minimal UTF8 implementation for number arrays. */
     namespace utf8 {
 
         /**
@@ -2760,15 +2544,6 @@ export namespace util {
          */
         function read(buffer: Uint8Array, start: number, end: number): string;
 
-        /**
-         * Reads UTF8 bytes as a string, rejecting invalid UTF8.
-         * @param buffer Source buffer
-         * @param start Source start
-         * @param end Source end
-         * @returns String read
-         */
-        function readStrict(buffer: Uint8Array, start: number, end: number): string;
-
         /**
          * Writes a string as UTF8 bytes.
          * @param string Source string
@@ -2778,109 +2553,6 @@ export namespace util {
          */
         function write(string: string, buffer: Uint8Array, offset: number): number;
     }
-
-    /** Node's fs module if available. */
-    let fs: { [k: string]: any };
-
-    /**
-     * 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 };
-
-    /**
-     * Removes the first matching value from an object.
-     * @param object Object to remove from
-     * @param value Value to remove
-     * @param [key] Optional key for fast path removal
-     * @returns `true` if removed, otherwise `false`
-     */
-    function remove(object: ({ [k: string]: any }|undefined), value: any, key?: string): boolean;
-
-    /**
-     * 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
-     * @deprecated Use {@link util.jsonName} for protobuf field JSON names.
-     */
-    function camelCase(str: string): string;
-
-    /**
-     * Converts a proto field name to its protoc-compatible JSON name.
-     * @param str Proto field name
-     * @returns JSON name
-     */
-    function jsonName(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;
 }
 
 /**
@@ -2898,7 +2570,7 @@ export const wrappers: { [k: string]: IWrapper };
  * @param object Plain object
  * @returns Message instance
  */
-export type WrapperFromObjectConverter = (this: Type, object: { [k: string]: any }) => Message<{}>;
+type WrapperFromObjectConverter = (this: Type, object: { [k: string]: any }) => Message<{}>;
 
 /**
  * To object converter part of an {@link IWrapper}.
@@ -2906,7 +2578,7 @@ export type WrapperFromObjectConverter = (this: Type, object: { [k: string]: any
  * @param [options] Conversion options
  * @returns Plain object
  */
-export type WrapperToObjectConverter = (this: Type, message: Message<{}>, options?: IConversionOptions) => { [k: string]: any };
+type WrapperToObjectConverter = (this: Type, message: Message<{}>, options?: IConversionOptions) => { [k: string]: any };
 
 /** Common type wrapper part of {@link wrappers}. */
 export interface IWrapper {
@@ -2918,66 +2590,57 @@ export interface IWrapper {
     toObject?: WrapperToObjectConverter;
 }
 
-/** Wire format writer using `Uint8Array`. */
+/** Wire format writer using `Uint8Array` if available, otherwise `Array`. */
 export class Writer {
 
     /** Constructs a new writer instance. */
     constructor();
 
-    /** Write cursor into {@link Writer#buf}. */
-    pos: number;
-
-    /** Backing buffer. */
-    buf: Uint8Array;
+    /** Current length. */
+    public len: number;
 
-    /** Cached DataView over {@link Writer#buf}. */
-    view: (DataView|null);
+    /** Operations head. */
+    public head: object;
 
-    /** Stack of forked length-prefix positions. */
-    states: (number[]|null);
+    /** Operations tail */
+    public tail: object;
 
-    /** Initial backing buffer size in bytes. Defaults to 128. */
-    static initialBufferSize: number;
-
-    /**
-     * Current write position.
-     * @deprecated Use {@link Writer#pos} instead.
-     */
-    len: number;
+    /** Linked forked states. */
+    public states: (object|null);
 
     /**
      * Creates a new writer.
      * @returns A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
      */
-    static create(): (BufferWriter|Writer);
+    public static create(): (BufferWriter|Writer);
 
     /**
      * Allocates a buffer of the specified size.
      * @param size Buffer size
      * @returns Buffer
      */
-    static alloc(size: number): Uint8Array;
+    public static alloc(size: number): Uint8Array;
 
     /**
      * Writes an unsigned 32 bit value as a varint.
      * @param value Value to write
      * @returns `this`
      */
-    uint32(value: number): Writer;
+    public uint32(value: number): Writer;
 
     /**
      * Writes a signed 32 bit value as a varint.
      * @param value Value to write
      * @returns `this`
      */
-    int32(value: number): Writer;
+    public int32(value: number): Writer;
 
     /**
      * Writes a 32 bit value as a varint, zig-zag encoded.
      * @param value Value to write
      * @returns `this`
      */
-    sint32(value: number): Writer;
+    public sint32(value: number): Writer;
 
     /**
      * Writes an unsigned 64 bit value as a varint.
@@ -2985,7 +2648,7 @@ export class Writer {
      * @returns `this`
      * @throws {TypeError} If `value` is a string and no long library is present.
      */
-    uint64(value: (Long|number|string)): Writer;
+    public uint64(value: (Long|number|string)): Writer;
 
     /**
      * Writes a signed 64 bit value as a varint.
@@ -2993,7 +2656,7 @@ export class Writer {
      * @returns `this`
      * @throws {TypeError} If `value` is a string and no long library is present.
      */
-    int64(value: (Long|number|string)): Writer;
+    public int64(value: (Long|number|string)): Writer;
 
     /**
      * Writes a signed 64 bit value as a varint, zig-zag encoded.
@@ -3001,28 +2664,28 @@ export class Writer {
      * @returns `this`
      * @throws {TypeError} If `value` is a string and no long library is present.
      */
-    sint64(value: (Long|number|string)): Writer;
+    public sint64(value: (Long|number|string)): Writer;
 
     /**
      * Writes a boolish value as a varint.
      * @param value Value to write
      * @returns `this`
      */
-    bool(value: boolean): Writer;
+    public bool(value: boolean): Writer;
 
     /**
      * Writes an unsigned 32 bit value as fixed 32 bits.
      * @param value Value to write
      * @returns `this`
      */
-    fixed32(value: number): Writer;
+    public fixed32(value: number): Writer;
 
     /**
      * Writes a signed 32 bit value as fixed 32 bits.
      * @param value Value to write
      * @returns `this`
      */
-    sfixed32(value: number): Writer;
+    public sfixed32(value: number): Writer;
 
     /**
      * Writes an unsigned 64 bit value as fixed 64 bits.
@@ -3030,7 +2693,7 @@ export class Writer {
      * @returns `this`
      * @throws {TypeError} If `value` is a string and no long library is present.
      */
-    fixed64(value: (Long|number|string)): Writer;
+    public fixed64(value: (Long|number|string)): Writer;
 
     /**
      * Writes a signed 64 bit value as fixed 64 bits.
@@ -3038,169 +2701,60 @@ export class Writer {
      * @returns `this`
      * @throws {TypeError} If `value` is a string and no long library is present.
      */
-    sfixed64(value: (Long|number|string)): Writer;
+    public sfixed64(value: (Long|number|string)): Writer;
 
     /**
      * Writes a float (32 bit).
      * @param value Value to write
      * @returns `this`
      */
-    float(value: number): Writer;
+    public float(value: number): Writer;
 
     /**
      * Writes a double (64 bit float).
      * @param value Value to write
      * @returns `this`
      */
-    double(value: number): Writer;
+    public double(value: number): Writer;
 
     /**
      * Writes a sequence of bytes.
      * @param value Buffer or base64 encoded string to write
      * @returns `this`
      */
-    bytes(value: (Uint8Array|string)): Writer;
-
-    /**
-     * Writes raw bytes without a tag or length prefix.
-     * @param value Raw bytes
-     * @returns `this`
-     */
-    raw(value: Uint8Array): Writer;
+    public bytes(value: (Uint8Array|string)): Writer;
 
     /**
      * Writes a string.
      * @param value Value to write
      * @returns `this`
      */
-    string(value: string): Writer;
-
-    /**
-     * Writes an array of unsigned 32 bit values as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    uint32s(value: number[]): Writer;
-
-    /**
-     * Writes an array of signed 32 bit values as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    int32s(value: number[]): Writer;
-
-    /**
-     * Writes an array of 32 bit values as packed, zig-zag encoded varints.
-     * @param value Values to write
-     * @returns `this`
-     */
-    sint32s(value: number[]): Writer;
-
-    /**
-     * Writes an array of unsigned 64 bit values as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    uint64s(value: (Long|number|string)[]): Writer;
-
-    /**
-     * Writes an array of signed 64 bit values as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    int64s(value: (Long|number|string)[]): Writer;
-
-    /**
-     * Writes an array of 64 bit values as packed, zig-zag encoded varints.
-     * @param value Values to write
-     * @returns `this`
-     */
-    sint64s(value: (Long|number|string)[]): Writer;
-
-    /**
-     * Writes an array of boolish values as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    bools(value: boolean[]): Writer;
-
-    /**
-     * Writes an array of unsigned 32 bit values as packed, fixed 32 bits.
-     * @param value Values to write
-     * @returns `this`
-     */
-    fixed32s(value: number[]): Writer;
-
-    /**
-     * Writes an array of signed 32 bit values as packed, fixed 32 bits.
-     * @param value Values to write
-     * @returns `this`
-     */
-    sfixed32s(value: number[]): Writer;
-
-    /**
-     * Writes an array of unsigned 64 bit values as packed, fixed 64 bits.
-     * @param value Values to write
-     * @returns `this`
-     */
-    fixed64s(value: (Long|number|string)[]): Writer;
-
-    /**
-     * Writes an array of signed 64 bit values as packed, fixed 64 bits.
-     * @param value Values to write
-     * @returns `this`
-     */
-    sfixed64s(value: (Long|number|string)[]): Writer;
-
-    /**
-     * Writes an array of floats (32 bit) as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    floats(value: number[]): Writer;
-
-    /**
-     * Writes an array of doubles (64 bit float) as a packed repeated field.
-     * @param value Values to write
-     * @returns `this`
-     */
-    doubles(value: number[]): Writer;
+    public string(value: string): Writer;
 
     /**
      * Forks this writer's state by pushing it to a stack.
+     * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
      * @returns `this`
      */
-    fork(): Writer;
+    public fork(): Writer;
 
     /**
      * Resets this instance to the last state.
      * @returns `this`
      */
-    reset(): Writer;
+    public reset(): Writer;
 
     /**
-     * Resets to the last state and prepends the fork state's current write length as a varint.
+     * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
      * @returns `this`
      */
-    ldelim(): Writer;
+    public ldelim(): Writer;
 
     /**
      * Finishes the write operation.
-     * Returns a buffer sized to the written data by default.
-     * @param [shared=false] Whether to return a shared view instead of a unique copy
      * @returns Finished buffer
      */
-    finish(shared?: boolean): 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#pos} bytes.
-     * @param buf Target buffer
-     * @param [offset=0] Offset to start writing at
-     * @returns The provided buffer
-     */
-    finishInto<T extends Uint8Array>(buf: T, offset?: number): T;
+    public finish(): Uint8Array;
 }
 
 /** Wire format writer using node buffers. */
@@ -3214,11 +2768,65 @@ export class BufferWriter extends Writer {
      * @param size Buffer size
      * @returns Buffer
      */
-    static alloc(size: number): Buffer;
+    public static alloc(size: number): Buffer;
 
     /**
      * Finishes the write operation.
      * @returns Finished buffer
      */
-    finish(): 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;