// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run types'.

// version protobufjs@6.10.1
// export namespace protobuf {

    /**
     * Provides common type definitions.
     * Can also be used to provide additional google types or your own custom types.
     * @param name Short name as in `google/protobuf/[name].proto` or full file name
     * @param json JSON definition within `google.protobuf` if a short name, otherwise the file's root definition
     */
    export function common(name: string, json: { [k: string]: any }): void;

    export namespace common {

        /** Properties of a google.protobuf.Any message. */
        interface IAny {
            typeUrl?: string;
            bytes?: Uint8Array;
        }

        /** Properties of a google.protobuf.Duration message. */
        interface IDuration {
            seconds?: (number | Long);
            nanos?: number;
        }

        /** Properties of a google.protobuf.Timestamp message. */
        interface ITimestamp {
            seconds?: (number | Long);
            nanos?: number;
        }

        /** Properties of a google.protobuf.Empty message. */
        interface IEmpty {
        }

        /** Properties of a google.protobuf.Struct message. */
        interface IStruct {
            fields?: { [k: string]: IValue };
        }

        /** Properties of a google.protobuf.Value message. */
        interface IValue {
            kind?: string;
            nullValue?: 0;
            numberValue?: number;
            stringValue?: string;
            boolValue?: boolean;
            structValue?: IStruct;
            listValue?: IListValue;
        }

        /** Properties of a google.protobuf.ListValue message. */
        interface IListValue {
            values?: IValue[];
        }

        /** Properties of a google.protobuf.DoubleValue message. */
        interface IDoubleValue {
            value?: number;
        }

        /** Properties of a google.protobuf.FloatValue message. */
        interface IFloatValue {
            value?: number;
        }

        /** Properties of a google.protobuf.Int64Value message. */
        interface IInt64Value {
            value?: (number | Long);
        }

        /** Properties of a google.protobuf.UInt64Value message. */
        interface IUInt64Value {
            value?: (number | Long);
        }

        /** Properties of a google.protobuf.Int32Value message. */
        interface IInt32Value {
            value?: number;
        }

        /** Properties of a google.protobuf.UInt32Value message. */
        interface IUInt32Value {
            value?: number;
        }

        /** Properties of a google.protobuf.BoolValue message. */
        interface IBoolValue {
            value?: boolean;
        }

        /** Properties of a google.protobuf.StringValue message. */
        interface IStringValue {
            value?: string;
        }

        /** Properties of a google.protobuf.BytesValue message. */
        interface IBytesValue {
            value?: Uint8Array;
        }

        /**
         * Gets the root definition of the specified common proto file.
         *
         * Bundled definitions are:
         * - google/protobuf/any.proto
         * - google/protobuf/duration.proto
         * - google/protobuf/empty.proto
         * - google/protobuf/field_mask.proto
         * - google/protobuf/struct.proto
         * - google/protobuf/timestamp.proto
         * - google/protobuf/wrappers.proto
         *
         * @param file Proto file name
         * @returns Root definition or `null` if not defined
         */
        function get(file: string): (INamespace | null);
    }

    /** Runtime message from/to plain object converters. */
    export namespace converter {

        /**
         * Generates a plain object to runtime message converter specific to the specified message type.
         * @param mtype Message type
         * @returns Codegen instance
         */
        function fromObject(mtype: Type): Codegen;

        /**
         * Generates a runtime message to plain object converter specific to the specified message type.
         * @param mtype Message type
         * @returns Codegen instance
         */
        function toObject(mtype: Type): Codegen;
    }

    /**
     * Generates a decoder specific to the specified message type.
     * @param mtype Message type
     * @returns Codegen instance
     */
    export function decoder(mtype: Type): Codegen;

    /**
     * Generates an encoder specific to the specified message type.
     * @param mtype Message type
     * @returns Codegen instance
     */
    export function encoder(mtype: Type): Codegen;

    /** Reflected enum. */
    export class Enum extends ReflectionObject {

        /**
         * Constructs a new enum instance.
         * @param name Unique name within its namespace
         * @param [values] Enum values as an object, by name
         * @param [options] Declared options
         * @param [comment] The comment for this enum
         * @param [comments] The value comments for this enum
         */
        constructor(name: string, values?: { [k: string]: number }, options?: { [k: string]: any }, comment?: string, comments?: { [k: string]: string });

        /** Enum values by id. */
        public valuesById: { [k: number]: string };

        /** Enum values by name. */
        public values: { [k: string]: number };

        /** Enum comment text. */
        public comment: (string | null);

        /** Value comment texts, if any. */
        public comments: { [k: string]: string };

        /** Reserved ranges, if any. */
        public reserved: (number[] | string)[];

        /**
         * Constructs an enum from an enum descriptor.
         * @param name Enum name
         * @param json Enum descriptor
         * @returns Created enum
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: IEnum): Enum;

        /**
         * Converts this enum to an enum descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Enum descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IEnum;

        /**
         * Adds a value to this enum.
         * @param name Value name
         * @param id Value id
         * @param [comment] Comment, if any
         * @returns `this`
         * @throws {TypeError} If arguments are invalid
         * @throws {Error} If there is already a value with this name or id
         */
        public add(name: string, id: number, comment?: string): Enum;

        /**
         * Removes a value from this enum
         * @param name Value name
         * @returns `this`
         * @throws {TypeError} If arguments are invalid
         * @throws {Error} If `name` is not a name of this enum
         */
        public remove(name: string): Enum;

        /**
         * Tests if the specified id is reserved.
         * @param id Id to test
         * @returns `true` if reserved, otherwise `false`
         */
        public isReservedId(id: number): boolean;

        /**
         * Tests if the specified name is reserved.
         * @param name Name to test
         * @returns `true` if reserved, otherwise `false`
         */
        public isReservedName(name: string): boolean;
    }

    /** Enum descriptor. */
    export interface IEnum {

        /** Enum values */
        values: { [k: string]: number };

        /** Enum options */
        options?: { [k: string]: any };
    }

    /** Reflected message field. */
    export class Field extends FieldBase {

        /**
         * Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.
         * @param name Unique name within its namespace
         * @param id Unique id within its namespace
         * @param type Value type
         * @param [rule="optional"] Field rule
         * @param [extend] Extended type if different from parent
         * @param [options] Declared options
         */
        constructor(name: string, id: number, type: string, rule?: (string | { [k: string]: any }), extend?: (string | { [k: string]: any }), options?: { [k: string]: any });

        /**
         * Constructs a field from a field descriptor.
         * @param name Field name
         * @param json Field descriptor
         * @returns Created field
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: IField): Field;

        /** Determines whether this field is packed. Only relevant when repeated and working with proto2. */
        public readonly packed: boolean;

        /**
         * Field decorator (TypeScript).
         * @param fieldId Field id
         * @param fieldType Field type
         * @param [fieldRule="optional"] Field rule
         * @param [defaultValue] Default value
         * @returns Decorator function
         */
        public static d<T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]>(fieldId: number, fieldType: ("double" | "float" | "int32" | "uint32" | "sint32" | "fixed32" | "sfixed32" | "int64" | "uint64" | "sint64" | "fixed64" | "sfixed64" | "string" | "bool" | "bytes" | object), fieldRule?: ("optional" | "required" | "repeated"), defaultValue?: T): FieldDecorator;

        /**
         * Field decorator (TypeScript).
         * @param fieldId Field id
         * @param fieldType Field type
         * @param [fieldRule="optional"] Field rule
         * @returns Decorator function
         */
        public static d<T extends Message<T>>(fieldId: number, fieldType: (Constructor<T> | string), fieldRule?: ("optional" | "required" | "repeated")): FieldDecorator;
    }

    /** Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions. */
    export class FieldBase extends ReflectionObject {

        /**
         * Not an actual constructor. Use {@link Field} instead.
         * @param name Unique name within its namespace
         * @param id Unique id within its namespace
         * @param type Value type
         * @param [rule="optional"] Field rule
         * @param [extend] Extended type if different from parent
         * @param [options] Declared options
         * @param [comment] Comment associated with this field
         */
        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. */
        public rule?: string;

        /** Field type. */
        public type: string;

        /** Unique field id. */
        public id: number;

        /** Extended type if different from parent. */
        public extend?: string;

        /** Whether this field is required. */
        public required: boolean;

        /** Whether this field is optional. */
        public optional: boolean;

        /** Whether this field is repeated. */
        public repeated: boolean;

        /** Whether this field is a map or not. */
        public map: boolean;

        /** Message this field belongs to. */
        public message: (Type | null);

        /** OneOf this field belongs to, if any, */
        public partOf: (OneOf | null);

        /** The field type's default value. */
        public typeDefault: any;

        /** The field's default value on prototypes. */
        public defaultValue: any;

        /** Whether this field's value should be treated as a long. */
        public long: boolean;

        /** Whether this field's value is a buffer. */
        public bytes: boolean;

        /** Resolved type if not a basic type. */
        public resolvedType: (Type | Enum | null);

        /** Sister-field within the extended type if a declaring extension field. */
        public extensionField: (Field | null);

        /** Sister-field within the declaring namespace if an extended field. */
        public declaringField: (Field | null);

        /** Comment for this field. */
        public comment: (string | null);

        /**
         * Converts this field to a field descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Field descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IField;

        /**
         * Resolves this field's type references.
         * @returns `this`
         * @throws {Error} If any reference cannot be resolved
         */
        public resolve(): Field;
    }

    /** Field descriptor. */
    export interface IField {

        /** Field rule */
        rule?: string;

        /** Field type */
        type: string;

        /** Field id */
        id: number;

        /** Field options */
        options?: { [k: string]: any };
    }

    /** Extension field descriptor. */
    export interface IExtensionField extends IField {

        /** Extended type */
        extend: string;
    }

    /**
     * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
     * @param prototype Target prototype
     * @param fieldName Field name
     */
    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
     */
    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.
     * @param filename One or multiple files to load
     * @param root Root namespace, defaults to create a new one if omitted.
     * @param callback Callback function
     * @see {@link Root#load}
     */
    export function load(filename: (string | string[]), root: Root, callback: LoadCallback): void;

    /**
     * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
     * @param filename One or multiple files to load
     * @param callback Callback function
     * @see {@link Root#load}
     */
    export function load(filename: (string | string[]), callback: LoadCallback): void;

    /**
     * Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.
     * @param filename One or multiple files to load
     * @param [root] Root namespace, defaults to create a new one if omitted.
     * @returns Promise
     * @see {@link Root#load}
     */
    export function load(filename: (string | string[]), root?: Root): Promise<Root>;

    /**
     * Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
     * @param filename One or multiple files to load
     * @param [root] Root namespace, defaults to create a new one if omitted.
     * @returns Root namespace
     * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
     * @see {@link Root#loadSync}
     */
    export function loadSync(filename: (string | string[]), root?: Root): Root;

    /** Build type, one of `"full"`, `"light"` or `"minimal"`. */
    export const build: string;

    /** Reconfigures the library according to the environment. */
    export function configure(): void;

    /** Reflected map field. */
    export class MapField extends FieldBase {

        /**
         * Constructs a new map field instance.
         * @param name Unique name within its namespace
         * @param id Unique id within its namespace
         * @param keyType Key type
         * @param type Value type
         * @param [options] Declared options
         * @param [comment] Comment associated with this field
         */
        constructor(name: string, id: number, keyType: string, type: string, options?: { [k: string]: any }, comment?: string);

        /** Key type. */
        public keyType: string;

        /** Resolved key type if not a basic type. */
        public resolvedKeyType: (ReflectionObject | null);

        /**
         * Constructs a map field from a map field descriptor.
         * @param name Field name
         * @param json Map field descriptor
         * @returns Created map field
         * @throws {TypeError} If arguments are invalid
         */
        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
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IMapField;

        /**
         * Map field decorator (TypeScript).
         * @param fieldId Field id
         * @param fieldKeyType Field key type
         * @param fieldValueType Field value type
         * @returns Decorator function
         */
        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. */
    export interface IMapField extends IField {

        /** Key type */
        keyType: string;
    }

    /** Extension map field descriptor. */
    export interface IExtensionMapField extends IMapField {

        /** Extended type */
        extend: string;
    }

    /** Abstract runtime message. */
    export class Message<T extends object = object> {

        /**
         * Constructs a new message instance.
         * @param [properties] Properties to set
         */
        constructor(properties?: Properties<T>);

        /** Reference to the reflected type. */
        public static readonly $type: Type;

        /** Reference to the reflected type. */
        public readonly $type: Type;

        /**
         * Creates a new message of this type using the specified properties.
         * @param [properties] Properties to set
         * @returns Message instance
         */
        public static create<T extends Message<T>>(this: Constructor<T>, properties?: { [k: string]: any }): Message<T>;

        /**
         * Encodes a message of this type.
         * @param message Message to encode
         * @param [writer] Writer to use
         * @returns 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.
         * @param message Message to encode
         * @param [writer] Writer to use
         * @returns 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
         */
        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
         */
        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
         */
        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
         */
        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.
         * @param message Message instance
         * @param [options] Conversion options
         * @returns Plain object
         */
        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
         */
        public toJSON(): { [k: string]: any };
    }

    /** Reflected service method. */
    export class Method extends ReflectionObject {

        /**
         * Constructs a new service method instance.
         * @param name Method name
         * @param type Method type, usually `"rpc"`
         * @param requestType Request message type
         * @param responseType Response message type
         * @param [requestStream] Whether the request is streamed
         * @param [responseStream] Whether the response is streamed
         * @param [options] Declared options
         * @param [comment] The comment for this method
         */
        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);

        /** Method type. */
        public type: string;

        /** Request type. */
        public requestType: string;

        /** Whether requests are streamed or not. */
        public requestStream?: boolean;

        /** Response type. */
        public responseType: string;

        /** Whether responses are streamed or not. */
        public responseStream?: boolean;

        /** Resolved request type. */
        public resolvedRequestType: (Type | null);

        /** Resolved response type. */
        public resolvedResponseType: (Type | null);

        /** Comment for this method */
        public comment: (string | null);

        /**
         * Constructs a method from a method descriptor.
         * @param name Method name
         * @param json Method descriptor
         * @returns Created method
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: IMethod): Method;

        /**
         * Converts this method to a method descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Method descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IMethod;
    }

    /** Method descriptor. */
    export interface IMethod {

        /** Method type */
        type?: string;

        /** Request type */
        requestType: string;

        /** Response type */
        responseType: string;

        /** Whether requests are streamed */
        requestStream?: boolean;

        /** Whether responses are streamed */
        responseStream?: boolean;

        /** Method options */
        options?: { [k: string]: any };
    }

    /** Reflected namespace. */
    export class Namespace extends NamespaceBase {

        /**
         * Constructs a new namespace instance.
         * @param name Namespace name
         * @param [options] Declared options
         */
        constructor(name: string, options?: { [k: string]: any });

        /**
         * Constructs a namespace from JSON.
         * @param name Namespace name
         * @param json JSON object
         * @returns Created namespace
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: { [k: string]: any }): Namespace;

        /**
         * Converts an array of reflection objects to JSON.
         * @param array Object array
         * @param [toJSONOptions] JSON conversion options
         * @returns JSON object or `undefined` when array is empty
         */
        public static arrayToJSON(array: ReflectionObject[], toJSONOptions?: IToJSONOptions): ({ [k: string]: any } | undefined);

        /**
         * Tests if the specified id is reserved.
         * @param reserved Array of reserved ranges and names
         * @param id Id to test
         * @returns `true` if reserved, otherwise `false`
         */
        public static isReservedId(reserved: ((number[] | string)[] | undefined), id: number): boolean;

        /**
         * Tests if the specified name is reserved.
         * @param reserved Array of reserved ranges and names
         * @param name Name to test
         * @returns `true` if reserved, otherwise `false`
         */
        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. */
        public nested?: { [k: string]: ReflectionObject };

        /** Nested objects of this namespace as an array for iteration. */
        public readonly nestedArray: ReflectionObject[];

        /**
         * Converts this namespace to a namespace descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Namespace descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): INamespace;

        /**
         * Adds nested objects to this namespace from nested object descriptors.
         * @param nestedJson Any nested object descriptors
         * @returns `this`
         */
        public addJSON(nestedJson: { [k: string]: AnyNestedObject }): 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
         */
        public get(name: string): (ReflectionObject | null);

        /**
         * Gets the values of the nested {@link Enum|enum} of the specified name.
         * This methods differs from {@link Namespace#get|get} in that it returns an enum's values directly and throws instead of returning `null`.
         * @param name Nested enum name
         * @returns Enum values
         * @throws {Error} If there is no such enum
         */
        public getEnum(name: string): { [k: string]: number };

        /**
         * Adds a nested object to this namespace.
         * @param object Nested object to add
         * @returns `this`
         * @throws {TypeError} If arguments are invalid
         * @throws {Error} If there is already a nested object with this name
         */
        public add(object: ReflectionObject): Namespace;

        /**
         * Removes a nested object from this namespace.
         * @param object Nested object to remove
         * @returns `this`
         * @throws {TypeError} If arguments are invalid
         * @throws {Error} If `object` is not a member of this namespace
         */
        public remove(object: ReflectionObject): Namespace;

        /**
         * Defines additial namespaces within this one if not yet existing.
         * @param path Path to create
         * @param [json] Nested types to create from JSON
         * @returns Pointer to the last namespace created or `this` if path is empty
         */
        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`
         */
        public resolveAll(): Namespace;

        /**
         * Recursively looks up the reflection object matching the specified path in the scope of this namespace.
         * @param path Path to look up
         * @param filterTypes Filter types, any combination of the constructors of `protobuf.Type`, `protobuf.Enum`, `protobuf.Service` etc.
         * @param [parentAlreadyChecked=false] If known, whether the parent has already been checked
         * @returns Looked up object or `null` if none could be found
         */
        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.
         * @param path Path to look up
         * @param [parentAlreadyChecked=false] Whether the parent has already been checked
         * @returns Looked up object or `null` if none could be found
         */
        public lookup(path: (string | string[]), parentAlreadyChecked?: boolean): (ReflectionObject | null);

        /**
         * Looks up the {@link Type|type} at the specified path, relative to this namespace.
         * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
         * @param path Path to look up
         * @returns Looked up type
         * @throws {Error} If `path` does not point to a type
         */
        public lookupType(path: (string | string[])): Type;

        /**
         * Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.
         * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
         * @param path Path to look up
         * @returns Looked up enum
         * @throws {Error} If `path` does not point to an 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.
         * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
         * @param path Path to look up
         * @returns Looked up type or enum
         * @throws {Error} If `path` does not point to a type or enum
         */
        public lookupTypeOrEnum(path: (string | string[])): Type;

        /**
         * Looks up the {@link Service|service} at the specified path, relative to this namespace.
         * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
         * @param path Path to look up
         * @returns Looked up service
         * @throws {Error} If `path` does not point to a service
         */
        public lookupService(path: (string | string[])): Service;
    }

    /** Namespace descriptor. */
    export interface INamespace {

        /** Namespace options */
        options?: { [k: string]: any };

        /** Nested object descriptors */
        nested?: { [k: string]: AnyNestedObject };
    }

    /** Any extension field descriptor. */
    type AnyExtensionField = (IExtensionField | IExtensionMapField);

    /** Any nested object descriptor. */
    type AnyNestedObject = (IEnum | IType | IService | AnyExtensionField | INamespace);

    /** Base class of all reflection objects. */
    export abstract class ReflectionObject {

        /** Options. */
        public options?: { [k: string]: any };

        /** Parsed Options. */
        public parsedOptions?: { [k: string]: any[] };

        /** Unique name within its namespace. */
        public name: string;

        /** Parent namespace. */
        public parent: (Namespace | null);

        /** Whether already resolved or not. */
        public resolved: boolean;

        /** Comment text, if any. */
        public comment: (string | null);

        /** Defining file name. */
        public filename: (string | null);

        /** Reference to the root namespace. */
        public readonly root: Root;

        /** Full name including leading dot. */
        public readonly fullName: string;

        /**
         * Converts this reflection object to its descriptor representation.
         * @returns Descriptor
         */
        public toJSON(): { [k: string]: any };

        /**
         * Called when this object is added to a parent.
         * @param parent Parent added to
         */
        public onAdd(parent: ReflectionObject): void;

        /**
         * Called when this object is removed from a parent.
         * @param parent Parent removed from
         */
        public onRemove(parent: ReflectionObject): void;

        /**
         * Resolves this objects type references.
         * @returns `this`
         */
        public resolve(): ReflectionObject;

        /**
         * Gets an option value.
         * @param name Option name
         * @returns Option value or `undefined` if not set
         */
        public getOption(name: string): any;

        /**
         * Sets an option.
         * @param name Option name
         * @param value Option value
         * @param [ifNotSet] Sets the option only if it isn't currently set
         * @returns `this`
         */
        public setOption(name: string, value: any, ifNotSet?: boolean): ReflectionObject;

        /**
         * Sets a parsed option.
         * @param name parsed Option name
         * @param value Option value
         * @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`
         */
        public setParsedOption(name: string, value: any, propName: string): ReflectionObject;

        /**
         * Sets multiple options.
         * @param options Options to set
         * @param [ifNotSet] Sets an option only if it isn't currently set
         * @returns `this`
         */
        public setOptions(options: { [k: string]: any }, ifNotSet?: boolean): ReflectionObject;

        /**
         * Converts this instance to its string representation.
         * @returns Class name[, space, full name]
         */
        public toString(): string;
    }

    /** Reflected oneof. */
    export class OneOf extends ReflectionObject {

        /**
         * Constructs a new oneof instance.
         * @param name Oneof name
         * @param [fieldNames] Field names
         * @param [options] Declared options
         * @param [comment] Comment associated with this field
         */
        constructor(name: string, fieldNames?: (string[] | { [k: string]: any }), options?: { [k: string]: any }, comment?: string);

        /** Field names that belong to this oneof. */
        public oneof: string[];

        /** Fields that belong to this oneof as an array for iteration. */
        public readonly fieldsArray: Field[];

        /** Comment for this field. */
        public comment: (string | null);

        /**
         * Constructs a oneof from a oneof descriptor.
         * @param name Oneof name
         * @param json Oneof descriptor
         * @returns Created oneof
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: IOneOf): OneOf;

        /**
         * Converts this oneof to a oneof descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Oneof descriptor
         */
        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`
         */
        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`
         */
        public remove(field: Field): OneOf;

        /**
         * OneOf decorator (TypeScript).
         * @param fieldNames Field names
         * @returns Decorator function
         */
        public static d<T extends string>(...fieldNames: string[]): OneOfDecorator;
    }

    /** Oneof descriptor. */
    export interface IOneOf {

        /** Oneof field names */
        oneof: string[];

        /** Oneof options */
        options?: { [k: string]: any };
    }

    /**
     * Decorator function as returned by {@link OneOf.d} (TypeScript).
     * @param prototype Target prototype
     * @param oneofName OneOf name
     */
    type OneOfDecorator = (prototype: object, oneofName: string) => void;

    /**
     * Parses the given .proto source and returns an object with the parsed contents.
     * @param source Source contents
     * @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
     * @returns Parser result
     */
    export function parse(source: string, options?: IParseOptions): IParserResult;

    /** Result object returned from {@link parse}. */
    export interface IParserResult {

        /** Package name, if declared */
        package: (string | undefined);

        /** Imports, if any */
        imports: (string[] | undefined);

        /** Weak imports, if any */
        weakImports: (string[] | undefined);

        /** Syntax, if specified (either `"proto2"` or `"proto3"`) */
        syntax: (string | undefined);

        /** Populated root instance */
        root: Root;
    }

    /** Options modifying the behavior of {@link parse}. */
    export interface IParseOptions {

        /** Keeps field casing instead of converting to camel case */
        keepCase?: boolean;

        /** Recognize double-slash comments in addition to doc-block comments. */
        alternateCommentMode?: boolean;

        /** Use trailing comment when both leading comment and trailing comment exist. */
        preferTrailingComment?: boolean;
    }

    /** Options modifying the behavior of JSON serialization. */
    export interface IToJSONOptions {

        /** Serializes comments. */
        keepComments?: boolean;
    }

    /**
     * Parses the given .proto source and returns an object with the parsed contents.
     * @param source Source contents
     * @param root Root to populate
     * @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
     * @returns Parser result
     */
    export function parse(source: string, root: Root, options?: IParseOptions): IParserResult;

    /** Wire format reader using `Uint8Array` if available, otherwise `Array`. */
    export class Reader {

        /**
         * Constructs a new reader instance using the specified buffer.
         * @param buffer Buffer to read from
         */
        constructor(buffer: Uint8Array);

        /** Read buffer. */
        public buf: Uint8Array;

        /** Read buffer position. */
        public pos: number;

        /** Read buffer length. */
        public len: number;

        /**
         * Creates a new reader using the specified buffer.
         * @param buffer Buffer to read from
         * @returns A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
         * @throws {Error} If `buffer` is not a valid buffer
         */
        public static create(buffer: (Uint8Array | Buffer)): (Reader | BufferReader);

        /**
         * Reads a varint as an unsigned 32 bit value.
         * @returns Value read
         */
        public uint32(): number;

        /**
         * Reads a varint as a signed 32 bit value.
         * @returns Value read
         */
        public int32(): number;

        /**
         * Reads a zig-zag encoded varint as a signed 32 bit value.
         * @returns Value read
         */
        public sint32(): number;

        /**
         * Reads a varint as a signed 64 bit value.
         * @returns Value read
         */
        public int64(): Long;

        /**
         * Reads a varint as an unsigned 64 bit value.
         * @returns Value read
         */
        public uint64(): Long;

        /**
         * Reads a zig-zag encoded varint as a signed 64 bit value.
         * @returns Value read
         */
        public sint64(): Long;

        /**
         * Reads a varint as a boolean.
         * @returns Value read
         */
        public bool(): boolean;

        /**
         * Reads fixed 32 bits as an unsigned 32 bit integer.
         * @returns Value read
         */
        public fixed32(): number;

        /**
         * Reads fixed 32 bits as a signed 32 bit integer.
         * @returns Value read
         */
        public sfixed32(): number;

        /**
         * Reads fixed 64 bits.
         * @returns Value read
         */
        public fixed64(): Long;

        /**
         * Reads zig-zag encoded fixed 64 bits.
         * @returns Value read
         */
        public sfixed64(): Long;

        /**
         * Reads a float (32 bit) as a number.
         * @returns Value read
         */
        public float(): number;

        /**
         * Reads a double (64 bit float) as a number.
         * @returns Value read
         */
        public double(): number;

        /**
         * Reads a sequence of bytes preceeded by its length as a varint.
         * @returns Value read
         */
        public bytes(): Uint8Array;

        /**
         * Reads a string preceeded by its byte length as a varint.
         * @returns Value read
         */
        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`
         */
        public skip(length?: number): Reader;

        /**
         * Skips the next element of the specified wire type.
         * @param wireType Wire type received
         * @returns `this`
         */
        public skipType(wireType: number): Reader;
    }

    /** Wire format reader using node buffers. */
    export class BufferReader extends Reader {

        /**
         * Constructs a new buffer reader instance.
         * @param buffer Buffer to read from
         */
        constructor(buffer: Buffer);

        /**
         * Reads a sequence of bytes preceeded by its length as a varint.
         * @returns Value read
         */
        public bytes(): Buffer;
    }

    /** Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together. */
    export class Root extends NamespaceBase {

        /**
         * Constructs a new root namespace instance.
         * @param [options] Top level options
         */
        constructor(options?: { [k: string]: any });

        /** Deferred extension fields. */
        public deferred: Field[];

        /** Resolved file names of loaded files. */
        public files: string[];

        /**
         * Loads a namespace descriptor into a root namespace.
         * @param json Nameespace descriptor
         * @param [root] Root namespace, defaults to create a new one if omitted
         * @returns Root namespace
         */
        public static fromJSON(json: INamespace, root?: Root): Root;

        /**
         * Resolves the path of an imported file, relative to the importing origin.
         * This method exists so you can override it with your own logic in case your imports are scattered over multiple directories.
         * @param origin The file name of the importing file
         * @param target The file name being imported
         * @returns Resolved path to `target` or `null` to skip the file
         */
        public resolvePath(origin: string, target: string): (string | null);

        /**
         * Fetch content from file path or url
         * This method exists so you can override it with your own logic.
         * @param path File path or url
         * @param callback Callback function
         */
        public fetch(path: string, callback: FetchCallback): 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 options Parse options
         * @param callback Callback function
         */
        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
         */
        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.
         * @param filename Names of one or multiple files to load
         * @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
         * @returns Promise
         */
        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).
         * @param filename Names of one or multiple files to load
         * @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
         * @returns Root namespace
         * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
         */
        public loadSync(filename: (string | string[]), options?: IParseOptions): Root;
    }

    /**
     * Named roots.
     * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
     * Can also be used manually to make roots available accross modules.
     */
    export let roots: { [k: string]: Root };

    /** Streaming RPC helpers. */
    export namespace rpc {

        /**
         * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
         *
         * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
         * @param error Error, if any
         * @param [response] Response message
         */
        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}.
         * @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 {

            /**
             * Constructs a new RPC service instance.
             * @param rpcImpl RPC implementation
             * @param [requestDelimited=false] Whether requests are length-delimited
             * @param [responseDelimited=false] Whether responses are length-delimited
             */
            constructor(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);

            /** RPC implementation. Becomes `null` once the service is ended. */
            public rpcImpl: (RPCImpl | null);

            /** Whether requests are length-delimited. */
            public requestDelimited: boolean;

            /** Whether responses are length-delimited. */
            public responseDelimited: boolean;

            /**
             * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
             * @param method Reflected or static method
             * @param requestCtor Request constructor
             * @param responseCtor Response constructor
             * @param request Request message or plain object
             * @param callback Service callback
             */
            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`
             */
            public end(endedByRPC?: boolean): rpc.Service;
        }
    }

    /**
     * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
     * @param method Reflected or static method being called
     * @param requestData Request data
     * @param callback Callback function
     */
    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
     */
    type RPCImplCallback = (error: (Error | null), response?: (Uint8Array | null)) => void;

    /** Reflected service. */
    export class Service extends NamespaceBase {

        /**
         * Constructs a new service instance.
         * @param name Service name
         * @param [options] Service options
         * @throws {TypeError} If arguments are invalid
         */
        constructor(name: string, options?: { [k: string]: any });

        /** Service methods. */
        public methods: { [k: string]: Method };

        /**
         * Constructs a service from a service descriptor.
         * @param name Service name
         * @param json Service descriptor
         * @returns Created service
         * @throws {TypeError} If arguments are invalid
         */
        public static fromJSON(name: string, json: IService): Service;

        /**
         * Converts this service to a service descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Service descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IService;

        /** Methods of this service as an array for iteration. */
        public readonly methodsArray: Method[];

        /**
         * Creates a runtime service using the specified rpc implementation.
         * @param rpcImpl RPC implementation
         * @param [requestDelimited=false] Whether requests are length-delimited
         * @param [responseDelimited=false] Whether responses are length-delimited
         * @returns RPC service. Useful where requests and/or responses are streamed.
         */
        public create(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean): rpc.Service;
    }

    /** Service descriptor. */
    export interface IService extends INamespace {

        /** Method descriptors */
        methods: { [k: string]: IMethod };
    }

    /**
     * Gets the next token and advances.
     * @returns Next token or `null` on eof
     */
    type TokenizerHandleNext = () => (string | null);

    /**
     * Peeks for the next token.
     * @returns Next token or `null` on eof
     */
    type TokenizerHandlePeek = () => (string | null);

    /**
     * Pushes a token back to the stack.
     * @param token Token
     */
    type TokenizerHandlePush = (token: string) => void;

    /**
     * Skips the next token.
     * @param expected Expected token
     * @param [optional=false] If optional
     * @returns Whether the token matched
     * @throws {Error} If the token didn't match and is not optional
     */
    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
     */
    type TokenizerHandleCmnt = (line?: number) => (string | null);

    /** Handle object returned from {@link tokenize}. */
    export interface ITokenizerHandle {

        /** Gets the next token and advances (`null` on eof) */
        next: TokenizerHandleNext;

        /** Peeks for the next token (`null` on eof) */
        peek: TokenizerHandlePeek;

        /** Pushes a token back to the stack */
        push: TokenizerHandlePush;

        /** Skips a token, returns its presence and advances or, if non-optional and not present, throws */
        skip: TokenizerHandleSkip;

        /** Gets the comment on the previous line or the line comment on the specified line, if any */
        cmnt: TokenizerHandleCmnt;

        /** Current line number */
        line: number;
    }

    /**
     * Tokenizes the given .proto source and returns an object with useful utility functions.
     * @param source Source contents
     * @param alternateCommentMode Whether we should activate alternate comment parsing mode.
     * @returns Tokenizer handle
     */
    export function tokenize(source: string, alternateCommentMode: boolean): ITokenizerHandle;

    export namespace tokenize {

        /**
         * Unescapes a string.
         * @param str String to unescape
         * @returns Unescaped string
         */
        function unescape(str: string): string;
    }

    /** Reflected message type. */
    export class Type extends NamespaceBase {

        /**
         * Constructs a new reflected message type instance.
         * @param name Message name
         * @param [options] Declared options
         */
        constructor(name: string, options?: { [k: string]: any });

        /** Message fields. */
        public fields: { [k: string]: Field };

        /** Oneofs declared within this namespace, if any. */
        public oneofs: { [k: string]: OneOf };

        /** Extension ranges, if any. */
        public extensions: number[][];

        /** Reserved ranges, if any. */
        public reserved: (number[] | string)[];

        /** Message fields by id. */
        public readonly fieldsById: { [k: number]: Field };

        /** Fields of this message as an array for iteration. */
        public readonly fieldsArray: Field[];

        /** Oneofs of this message as an array for iteration. */
        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.
         */
        public ctor: Constructor<{}>;

        /**
         * Generates a constructor function for the specified type.
         * @param mtype Message type
         * @returns Codegen instance
         */
        public static generateConstructor(mtype: Type): Codegen;

        /**
         * Creates a message type from a message type descriptor.
         * @param name Message name
         * @param json Message type descriptor
         * @returns Created message type
         */
        public static fromJSON(name: string, json: IType): Type;

        /**
         * Converts this message type to a message type descriptor.
         * @param [toJSONOptions] JSON conversion options
         * @returns Message type descriptor
         */
        public toJSON(toJSONOptions?: IToJSONOptions): IType;

        /**
         * Adds a nested object to this type.
         * @param object Nested object to add
         * @returns `this`
         * @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
         */
        public add(object: ReflectionObject): Type;

        /**
         * Removes a nested object from this type.
         * @param object Nested object to remove
         * @returns `this`
         * @throws {TypeError} If arguments are invalid
         * @throws {Error} If `object` is not a member of this type
         */
        public remove(object: ReflectionObject): Type;

        /**
         * Tests if the specified id is reserved.
         * @param id Id to test
         * @returns `true` if reserved, otherwise `false`
         */
        public isReservedId(id: number): boolean;

        /**
         * Tests if the specified name is reserved.
         * @param name Name to test
         * @returns `true` if reserved, otherwise `false`
         */
        public isReservedName(name: string): boolean;

        /**
         * Creates a new message of this type using the specified properties.
         * @param [properties] Properties to set
         * @returns Message instance
         */
        public create(properties?: { [k: string]: any }): Message<{}>;

        /**
         * Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.
         * @returns `this`
         */
        public setup(): Type;

        /**
         * Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.
         * @param message Message instance or plain object
         * @param [writer] Writer to encode to
         * @returns 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.
         * @param message Message instance or plain object
         * @param [writer] Writer to encode to
         * @returns 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
         * @returns Decoded message
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {util.ProtocolError<{}>} If required fields are missing
         */
        public decode(reader: (Reader | Uint8Array), length?: number): Message<{}>;

        /**
         * Decodes a message of this type preceeded by its byte length as a varint.
         * @param reader Reader or buffer to decode from
         * @returns Decoded message
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {util.ProtocolError} If required fields are missing
         */
        public decodeDelimited(reader: (Reader | Uint8Array)): Message<{}>;

        /**
         * Verifies that field values are valid and that required fields are present.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public verify(message: { [k: string]: any }): (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
         * @returns Message instance
         */
        public fromObject(object: { [k: string]: any }): Message<{}>;

        /**
         * Creates a plain object from a message of this type. Also converts values to other types if specified.
         * @param message Message instance
         * @param [options] Conversion options
         * @returns Plain object
         */
        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
         */
        public static d<T extends Message<T>>(typeName?: string): TypeDecorator<T>;
    }

    /** Message type descriptor. */
    export interface IType extends INamespace {

        /** Oneof descriptors */
        oneofs?: { [k: string]: IOneOf };

        /** Field descriptors */
        fields: { [k: string]: IField };

        /** Extension ranges */
        extensions?: number[][];

        /** Reserved ranges */
        reserved?: number[][];

        /** Whether a legacy group or not */
        group?: boolean;
    }

    /** Conversion options as used by {@link Type#toObject} and {@link Message.toObject}. */
    export interface IConversionOptions {

        /**
         * Long conversion type.
         * Valid values are `String` and `Number` (the global types).
         * Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.
         */
        longs?: Function;

        /**
         * Enum value conversion type.
         * Only valid value is `String` (the global type).
         * Defaults to copy the present value, which is the numeric id.
         */
        enums?: Function;

        /**
         * Bytes value conversion type.
         * Valid values are `Array` and (a base64 encoded) `String` (the global types).
         * Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.
         */
        bytes?: Function;

        /** Also sets default values on the resulting object */
        defaults?: boolean;

        /** Sets empty arrays for missing repeated fields even if `defaults=false` */
        arrays?: boolean;

        /** Sets empty objects for missing map fields even if `defaults=false` */
        objects?: boolean;

        /** Includes virtual oneof properties set to the present field's name, if any */
        oneofs?: boolean;

        /** Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings */
        json?: boolean;
    }

    /**
     * Decorator function as returned by {@link Type.d} (TypeScript).
     * @param target Target constructor
     */
    type TypeDecorator<T extends Message<T>> = (target: Constructor<T>) => void;

    /** Common type constants. */
    export namespace types {

        /** Basic type wire types. */
        const basic: {
            "double": number,
            "float": number,
            "int32": number,
            "uint32": number,
            "sint32": number,
            "fixed32": number,
            "sfixed32": number,
            "int64": number,
            "uint64": number,
            "sint64": number,
            "fixed64": number,
            "sfixed64": number,
            "bool": number,
            "string": number,
            "bytes": number
        };

        /** Basic type defaults. */
        const defaults: {
            "double": number,
            "float": number,
            "int32": number,
            "uint32": number,
            "sint32": number,
            "fixed32": number,
            "sfixed32": number,
            "int64": number,
            "uint64": number,
            "sint64": number,
            "fixed64": number,
            "sfixed64": number,
            "bool": boolean,
            "string": string,
            "bytes": number[],
            "message": null
        };

        /** Basic long type wire types. */
        const long: {
            "int64": number,
            "uint64": number,
            "sint64": number,
            "fixed64": number,
            "sfixed64": number
        };

        /** Allowed types for map keys with their associated wire type. */
        const mapKey: {
            "int32": number,
            "uint32": number,
            "sint32": number,
            "fixed32": number,
            "sfixed32": number,
            "int64": number,
            "uint64": number,
            "sint64": number,
            "fixed64": number,
            "sfixed64": number,
            "bool": number,
            "string": number
        };

        /** Allowed types for packed repeated fields with their associated wire type. */
        const packed: {
            "double": number,
            "float": number,
            "int32": number,
            "uint32": number,
            "sint32": number,
            "fixed32": number,
            "sfixed32": number,
            "int64": number,
            "uint64": number,
            "sint64": number,
            "fixed64": number,
            "sfixed64": number,
            "bool": number
        };
    }

    /** Constructor type. */
    export interface Constructor<T> extends Function {
        new(...params: any[]): T; prototype: T;
    }

    /** Properties type. */
    type Properties<T> = { [P in keyof T]?: T[P] };

    /**
     * Any compatible Buffer instance.
     * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
     */
    export interface Buffer extends Uint8Array {
    }

    /**
     * Any compatible Long instance.
     * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
     */
    export interface Long {

        /** Low bits */
        low: number;

        /** High bits */
        high: number;

        /** Whether unsigned or not */
        unsigned: boolean;
    }

    /**
     * A OneOf getter as returned by {@link util.oneOfGetter}.
     * @returns Set field name, if any
     */
    type OneOfGetter = () => (string | undefined);

    /**
     * A OneOf setter as returned by {@link util.oneOfSetter}.
     * @param value Field name
     */
    type OneOfSetter = (value: (string | undefined)) => void;

    /** Various utility functions. */
    export namespace util {

        /** Helper class for working with the low and high bits of a 64 bit value. */
        class LongBits {

            /**
             * Constructs new long bits.
             * @param lo Low 32 bits, unsigned
             * @param hi High 32 bits, unsigned
             */
            constructor(lo: number, hi: number);

            /** Low bits. */
            public lo: number;

            /** High bits. */
            public hi: number;

            /** Zero bits. */
            public static zero: util.LongBits;

            /** Zero hash. */
            public static zeroHash: string;

            /**
             * Constructs new long bits from the specified number.
             * @param value Value
             * @returns Instance
             */
            public static fromNumber(value: number): util.LongBits;

            /**
             * Constructs new long bits from a number, long or string.
             * @param value Value
             * @returns Instance
             */
            public 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
             */
            public toNumber(unsigned?: boolean): number;

            /**
             * Converts this long bits to a long.
             * @param [unsigned=false] Whether unsigned or not
             * @returns Long
             */
            public toLong(unsigned?: boolean): Long;

            /**
             * Constructs new long bits from the specified 8 characters long hash.
             * @param hash Hash
             * @returns Bits
             */
            public static fromHash(hash: string): util.LongBits;

            /**
             * Converts this long bits to a 8 characters long hash.
             * @returns Hash
             */
            public toHash(): string;

            /**
             * Zig-zag encodes this long bits.
             * @returns `this`
             */
            public zzEncode(): util.LongBits;

            /**
             * Zig-zag decodes this long bits.
             * @returns `this`
             */
            public zzDecode(): util.LongBits;

            /**
             * Calculates the length of this longbits when encoded as a varint.
             * @returns Length
             */
            public length(): number;
        }

        /** Whether running within node or not. */
        let isNode: boolean;

        /** Global object reference. */
        let global: object;

        /** An immuable empty array. */
        const emptyArray: any[];

        /** An immutable empty object. */
        const emptyObject: object;

        /**
         * Tests if the specified value is an integer.
         * @param value Value to test
         * @returns `true` if the value is an integer
         */
        function isInteger(value: any): boolean;

        /**
         * Tests if the specified value is a string.
         * @param value Value to test
         * @returns `true` if the value is a string
         */
        function isString(value: any): boolean;

        /**
         * Tests if the specified value is a non-null object.
         * @param value Value to test
         * @returns `true` if the value is a non-null object
         */
        function isObject(value: any): boolean;

        /**
         * Checks if a property on a message is considered to be present.
         * This is an alias of {@link util.isSet}.
         * @param obj Plain object or message instance
         * @param prop Property name
         * @returns `true` if considered to be present, otherwise `false`
         */
        function isset(obj: object, prop: string): boolean;

        /**
         * Checks if a property on a message is considered to be present.
         * @param obj Plain object or message instance
         * @param prop Property name
         * @returns `true` if considered to be present, otherwise `false`
         */
        function isSet(obj: object, prop: string): boolean;

        /** Node's Buffer class if available. */
        let Buffer: Constructor<Buffer>;

        /**
         * Creates a new buffer of whatever type supported by the environment.
         * @param [sizeOrArray=0] Buffer size or number array
         * @returns Buffer
         */
        function newBuffer(sizeOrArray?: (number | number[])): (Uint8Array | Buffer);

        /** Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`. */
        let Array: Constructor<Uint8Array>;

        /** Long.js's Long class if available. */
        let Long: Constructor<Long>;

        /** Regular expression used to verify 2 bit (`bool`) map keys. */
        const key2Re: RegExp;

        /** Regular expression used to verify 32 bit (`int32` etc.) map keys. */
        const key32Re: RegExp;

        /** Regular expression used to verify 64 bit (`int64` etc.) map keys. */
        const key64Re: RegExp;

        /**
         * Converts a number or long to an 8 characters long hash string.
         * @param value Value to convert
         * @returns Hash
         */
        function longToHash(value: (Long | number)): string;

        /**
         * Converts an 8 characters long hash string to a long or number.
         * @param hash Hash
         * @param [unsigned=false] Whether unsigned or not
         * @returns Original value
         */
        function longFromHash(hash: string, unsigned?: boolean): (Long | number);

        /**
         * Merges the properties of the source object into the destination object.
         * @param dst Destination object
         * @param src Source object
         * @param [ifNotSet=false] Merges only if the key is not already set
         * @returns Destination object
         */
        function merge(dst: { [k: string]: any }, src: { [k: string]: any }, ifNotSet?: boolean): { [k: string]: any };

        /**
         * Converts the first character of a string to lower case.
         * @param str String to convert
         * @returns Converted string
         */
        function lcFirst(str: string): string;

        /**
         * Creates a custom error constructor.
         * @param name Error name
         * @returns Custom error constructor
         */
        function newError(name: string): Constructor<Error>;

        /** Error subclass indicating a protocol specifc error. */
        class ProtocolError<T extends Message<T>> extends Error {

            /**
             * 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 };

        /**
         * 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
         * @returns Destination object
         */
        function setProperty(dst: { [k: string]: any }, path: string, value: object): { [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
             */
            function readDoubleBE(buf: Uint8Array, pos: number): number;
        }

        /**
         * 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)>;

        /**
         * Requires a module only if available.
         * @param moduleName Module to require
         * @returns Required module if available and not empty, otherwise `null`
         */
        function inquire(moduleName: string): object;

        /** A minimal path module to resolve Unix, Windows and URL paths alike. */
        namespace path {

            /**
             * Tests if the specified path is absolute.
             * @param path Path to test
             * @returns `true` if path is absolute
             */
            function isAbsolute(path: string): boolean;

            /**
             * Normalizes the specified path.
             * @param path Path to normalize
             * @returns Normalized path
             */
            function normalize(path: string): string;

            /**
             * Resolves the specified include path against the specified origin path.
             * @param originPath Path to the origin file
             * @param includePath Include path relative to origin path
             * @param [alreadyNormalized=false] `true` if both paths are already known to be normalized
             * @returns Path to the include file
             */
            function resolve(originPath: string, includePath: string, alreadyNormalized?: boolean): string;
        }

        /**
         * A general purpose buffer pool.
         * @param alloc Allocator
         * @param slice Slicer
         * @param [size=8192] Slab size
         * @returns Pooled allocator
         */
        function pool(alloc: PoolAllocator, slice: PoolSlicer, size?: number): PoolAllocator;

        /** A minimal UTF8 implementation for number arrays. */
        namespace utf8 {

            /**
             * Calculates the UTF8 byte length of a string.
             * @param string String
             * @returns Byte length
             */
            function length(string: string): number;

            /**
             * Reads UTF8 bytes as a string.
             * @param buffer Source buffer
             * @param start Source start
             * @param end Source end
             * @returns String read
             */
            function read(buffer: Uint8Array, start: number, end: number): string;

            /**
             * Writes a string as UTF8 bytes.
             * @param string Source string
             * @param buffer Destination buffer
             * @param offset Destination offset
             * @returns Bytes written
             */
            function write(string: string, buffer: Uint8Array, offset: number): number;
        }
    }

    /**
     * Generates a verifier specific to the specified message type.
     * @param mtype Message type
     * @returns Codegen instance
     */
    export function verifier(mtype: Type): Codegen;

    /** Wrappers for common types. */
    export const wrappers: { [k: string]: IWrapper };

    /**
     * From object converter part of an {@link IWrapper}.
     * @param object Plain object
     * @returns Message instance
     */
    type WrapperFromObjectConverter = (this: Type, object: { [k: string]: any }) => Message<{}>;

    /**
     * To object converter part of an {@link IWrapper}.
     * @param message Message instance
     * @param [options] Conversion options
     * @returns Plain object
     */
    type WrapperToObjectConverter = (this: Type, message: Message<{}>, options?: IConversionOptions) => { [k: string]: any };

    /** Common type wrapper part of {@link wrappers}. */
    export interface IWrapper {

        /** From object converter */
        fromObject?: WrapperFromObjectConverter;

        /** To object converter */
        toObject?: WrapperToObjectConverter;
    }

    /** Wire format writer using `Uint8Array` if available, otherwise `Array`. */
    export class Writer {

        /** Constructs a new writer instance. */
        constructor();

        /** Current length. */
        public len: number;

        /** Operations head. */
        public head: object;

        /** Operations tail */
        public tail: object;

        /** Linked forked states. */
        public states: (object | null);

        /**
         * Creates a new writer.
         * @returns A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
         */
        public static create(): (BufferWriter | Writer);

        /**
         * Allocates a buffer of the specified size.
         * @param size Buffer size
         * @returns Buffer
         */
        public static alloc(size: number): Uint8Array;

        /**
         * Writes an unsigned 32 bit value as a varint.
         * @param value Value to write
         * @returns `this`
         */
        public uint32(value: number): Writer;

        /**
         * Writes a signed 32 bit value as a varint.
         * @param value Value to write
         * @returns `this`
         */
        public int32(value: number): Writer;

        /**
         * Writes a 32 bit value as a varint, zig-zag encoded.
         * @param value Value to write
         * @returns `this`
         */
        public sint32(value: number): Writer;

        /**
         * Writes an unsigned 64 bit value as a varint.
         * @param value Value to write
         * @returns `this`
         * @throws {TypeError} If `value` is a string and no long library is present.
         */
        public uint64(value: (Long | number | string)): Writer;

        /**
         * Writes a signed 64 bit value as a varint.
         * @param value Value to write
         * @returns `this`
         * @throws {TypeError} If `value` is a string and no long library is present.
         */
        public int64(value: (Long | number | string)): Writer;

        /**
         * Writes a signed 64 bit value as a varint, zig-zag encoded.
         * @param value Value to write
         * @returns `this`
         * @throws {TypeError} If `value` is a string and no long library is present.
         */
        public sint64(value: (Long | number | string)): Writer;

        /**
         * Writes a boolish value as a varint.
         * @param value Value to write
         * @returns `this`
         */
        public bool(value: boolean): Writer;

        /**
         * Writes an unsigned 32 bit value as fixed 32 bits.
         * @param value Value to write
         * @returns `this`
         */
        public fixed32(value: number): Writer;

        /**
         * Writes a signed 32 bit value as fixed 32 bits.
         * @param value Value to write
         * @returns `this`
         */
        public sfixed32(value: number): Writer;

        /**
         * Writes an unsigned 64 bit value as fixed 64 bits.
         * @param value Value to write
         * @returns `this`
         * @throws {TypeError} If `value` is a string and no long library is present.
         */
        public fixed64(value: (Long | number | string)): Writer;

        /**
         * Writes a signed 64 bit value as fixed 64 bits.
         * @param value Value to write
         * @returns `this`
         * @throws {TypeError} If `value` is a string and no long library is present.
         */
        public sfixed64(value: (Long | number | string)): Writer;

        /**
         * Writes a float (32 bit).
         * @param value Value to write
         * @returns `this`
         */
        public float(value: number): Writer;

        /**
         * Writes a double (64 bit float).
         * @param value Value to write
         * @returns `this`
         */
        public double(value: number): Writer;

        /**
         * Writes a sequence of bytes.
         * @param value Buffer or base64 encoded string to write
         * @returns `this`
         */
        public bytes(value: (Uint8Array | string)): Writer;

        /**
         * Writes a string.
         * @param value Value to write
         * @returns `this`
         */
        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`
         */
        public fork(): Writer;

        /**
         * Resets this instance to the last state.
         * @returns `this`
         */
        public reset(): Writer;

        /**
         * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
         * @returns `this`
         */
        public ldelim(): Writer;

        /**
         * Finishes the write operation.
         * @returns Finished buffer
         */
        public finish(): Uint8Array;
    }

    /** Wire format writer using node buffers. */
    export class BufferWriter extends Writer {

        /** Constructs a new buffer writer instance. */
        constructor();

        /**
         * Allocates a buffer of the specified size.
         * @param size Buffer size
         * @returns Buffer
         */
        public static alloc(size: number): Buffer;

        /**
         * Finishes the write operation.
         * @returns Finished buffer
         */
        public finish(): Buffer;
    }

    /**
     * Callback as used by {@link util.asPromise}.
     * @param error Error, if any
     * @param params Additional arguments
     */
    type asPromiseCallback = (error: (Error | null), ...params: any[]) => void;

    /**
     * Appends code to the function's body or finishes generation.
     * @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
     * @param [formatParams] Format parameters
     * @returns Itself or the generated function if finished
     * @throws {Error} If format parameter counts do not match
     */
    type Codegen = (formatStringOrScope?: (string | { [k: string]: any }), ...formatParams: any[]) => (Codegen | Function);

    /**
     * Event listener as used by {@link util.EventEmitter}.
     * @param args Arguments
     */
    type EventEmitterListener = (...args: any[]) => void;

    /**
     * Node-style callback as used by {@link util.fetch}.
     * @param error Error, if any, otherwise `null`
     * @param [contents] File contents, if there hasn't been an error
     */
    type FetchCallback = (error: Error, contents?: string) => void;

    /** Options as used by {@link util.fetch}. */
    export interface IFetchOptions {

        /** Whether expecting a binary response */
        binary?: boolean;

        /** If `true`, forces the use of XMLHttpRequest */
        xhr?: boolean;
    }

    /**
     * An allocator as used by {@link util.pool}.
     * @param size Buffer size
     * @returns Buffer
     */
    type PoolAllocator = (size: number) => Uint8Array;

    /**
     * A slicer as used by {@link util.pool}.
     * @param start Start offset
     * @param end End offset
     * @returns Buffer slice
     */
    type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
// }