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

export as 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 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

* @param [parsedOptions] Declared options, properly parsed into an object

*/

constructor(name: string, type: (string|undefined), requestType: string, responseType: string, requestStream?: (boolean|{ [k: string]: any }), responseStream?: (boolean|{ [k: string]: any }), options?: { [k: string]: any }, comment?: string, parsedOptions?: { [k: string]: any });

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

/** Options properly parsed into an object */

public parsedOptions: any;

/**

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

/** Method comments */

comment: string;

/** Method options properly parsed into an object */

parsedOptions?: { [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;