2695 lines
83 KiB
TypeScript
2695 lines
83 KiB
TypeScript
// 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 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 };
|
|
|
|
/** 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 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;
|
|
}
|
|
|
|
/** 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);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/** An immuable empty array. */
|
|
const emptyArray: any[];
|
|
|
|
/** An immutable empty object. */
|
|
const emptyObject: object;
|
|
|
|
/** Whether running within node or not. */
|
|
const isNode: boolean;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/** 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;
|