代码拉取完成，页面将自动刷新
同步操作将从 TopDiscover/QuickFramework 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run types'.
// version [email protected]
declare namespace protobuf {
/**
* Provides common type definitions.
* Can also be used to provide additional google types or your own custom types.
* @param name Short name as in `google/protobuf/[name].proto` or full file name
* @param json JSON definition within `google.protobuf` if a short name, otherwise the file's root definition
*/
export function common(name: string, json: { [k: string]: any }): void;
export namespace common {
/** Properties of a google.protobuf.Any message. */
interface IAny {
typeUrl?: string;
bytes?: Uint8Array;
}
/** Properties of a google.protobuf.Duration message. */
interface IDuration {
seconds?: (number | Long);
nanos?: number;
}
/** Properties of a google.protobuf.Timestamp message. */
interface ITimestamp {
seconds?: (number | Long);
nanos?: number;
}
/** Properties of a google.protobuf.Empty message. */
interface IEmpty {
}
/** Properties of a google.protobuf.Struct message. */
interface IStruct {
fields?: { [k: string]: IValue };
}
/** Properties of a google.protobuf.Value message. */
interface IValue {
kind?: string;
nullValue?: 0;
numberValue?: number;
stringValue?: string;
boolValue?: boolean;
structValue?: IStruct;
listValue?: IListValue;
}
/** Properties of a google.protobuf.ListValue message. */
interface IListValue {
values?: IValue[];
}
/** Properties of a google.protobuf.DoubleValue message. */
interface IDoubleValue {
value?: number;
}
/** Properties of a google.protobuf.FloatValue message. */
interface IFloatValue {
value?: number;
}
/** Properties of a google.protobuf.Int64Value message. */
interface IInt64Value {
value?: (number | Long);
}
/** Properties of a google.protobuf.UInt64Value message. */
interface IUInt64Value {
value?: (number | Long);
}
/** Properties of a google.protobuf.Int32Value message. */
interface IInt32Value {
value?: number;
}
/** Properties of a google.protobuf.UInt32Value message. */
interface IUInt32Value {
value?: number;
}
/** Properties of a google.protobuf.BoolValue message. */
interface IBoolValue {
value?: boolean;
}
/** Properties of a google.protobuf.StringValue message. */
interface IStringValue {
value?: string;
}
/** Properties of a google.protobuf.BytesValue message. */
interface IBytesValue {
value?: Uint8Array;
}
/**
* Gets the root definition of the specified common proto file.
*
* Bundled definitions are:
* - google/protobuf/any.proto
* - google/protobuf/duration.proto
* - google/protobuf/empty.proto
* - google/protobuf/field_mask.proto
* - google/protobuf/struct.proto
* - google/protobuf/timestamp.proto
* - google/protobuf/wrappers.proto
*
* @param file Proto file name
* @returns Root definition or `null` if not defined
*/
function get(file: string): (INamespace | null);
}
/** Runtime message from/to plain object converters. */
export namespace converter {
/**
* Generates a plain object to runtime message converter specific to the specified message type.
* @param mtype Message type
* @returns Codegen instance
*/
function fromObject(mtype: Type): Codegen;
/**
* Generates a runtime message to plain object converter specific to the specified message type.
* @param mtype Message type
* @returns Codegen instance
*/
function toObject(mtype: Type): Codegen;
}
/**
* Generates a decoder specific to the specified message type.
* @param mtype Message type
* @returns Codegen instance
*/
export function decoder(mtype: Type): Codegen;
/**
* Generates an encoder specific to the specified message type.
* @param mtype Message type
* @returns Codegen instance
*/
export function encoder(mtype: Type): Codegen;
/** Reflected enum. */
export class Enum extends ReflectionObject {
/**
* Constructs a new enum instance.
* @param name Unique name within its namespace
* @param [values] Enum values as an object, by name
* @param [options] Declared options
* @param [comment] The comment for this enum
* @param [comments] The value comments for this enum
*/
constructor(name: string, values?: { [k: string]: number }, options?: { [k: string]: any }, comment?: string, comments?: { [k: string]: string });
/** Enum values by id. */
public valuesById: { [k: number]: string };
/** Enum values by name. */
public values: { [k: string]: number };
/** Enum comment text. */
public comment: (string | null);
/** Value comment texts, if any. */
public comments: { [k: string]: string };
/** Reserved ranges, if any. */
public reserved: (number[] | string)[];
/**
* Constructs an enum from an enum descriptor.
* @param name Enum name
* @param json Enum descriptor
* @returns Created enum
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IEnum): Enum;
/**
* Converts this enum to an enum descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Enum descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IEnum;
/**
* Adds a value to this enum.
* @param name Value name
* @param id Value id
* @param [comment] Comment, if any
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a value with this name or id
*/
public add(name: string, id: number, comment?: string): Enum;
/**
* Removes a value from this enum
* @param name Value name
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `name` is not a name of this enum
*/
public remove(name: string): Enum;
/**
* Tests if the specified id is reserved.
* @param id Id to test
* @returns `true` if reserved, otherwise `false`
*/
public isReservedId(id: number): boolean;
/**
* Tests if the specified name is reserved.
* @param name Name to test
* @returns `true` if reserved, otherwise `false`
*/
public isReservedName(name: string): boolean;
}
/** Enum descriptor. */
export interface IEnum {
/** Enum values */
values: { [k: string]: number };
/** Enum options */
options?: { [k: string]: any };
}
/** Reflected message field. */
export class Field extends FieldBase {
/**
* Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.
* @param name Unique name within its namespace
* @param id Unique id within its namespace
* @param type Value type
* @param [rule="optional"] Field rule
* @param [extend] Extended type if different from parent
* @param [options] Declared options
*/
constructor(name: string, id: number, type: string, rule?: (string | { [k: string]: any }), extend?: (string | { [k: string]: any }), options?: { [k: string]: any });
/**
* Constructs a field from a field descriptor.
* @param name Field name
* @param json Field descriptor
* @returns Created field
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IField): Field;
/** Determines whether this field is packed. Only relevant when repeated and working with proto2. */
public readonly packed: boolean;
/**
* Field decorator (TypeScript).
* @param fieldId Field id
* @param fieldType Field type
* @param [fieldRule="optional"] Field rule
* @param [defaultValue] Default value
* @returns Decorator function
*/
public static d<T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]>(fieldId: number, fieldType: ("double" | "float" | "int32" | "uint32" | "sint32" | "fixed32" | "sfixed32" | "int64" | "uint64" | "sint64" | "fixed64" | "sfixed64" | "string" | "bool" | "bytes" | object), fieldRule?: ("optional" | "required" | "repeated"), defaultValue?: T): FieldDecorator;
/**
* Field decorator (TypeScript).
* @param fieldId Field id
* @param fieldType Field type
* @param [fieldRule="optional"] Field rule
* @returns Decorator function
*/
public static d<T extends Message<T>>(fieldId: number, fieldType: (Constructor<T> | string), fieldRule?: ("optional" | "required" | "repeated")): FieldDecorator;
}
/** Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions. */
export class FieldBase extends ReflectionObject {
/**
* Not an actual constructor. Use {@link Field} instead.
* @param name Unique name within its namespace
* @param id Unique id within its namespace
* @param type Value type
* @param [rule="optional"] Field rule
* @param [extend] Extended type if different from parent
* @param [options] Declared options
* @param [comment] Comment associated with this field
*/
constructor(name: string, id: number, type: string, rule?: (string | { [k: string]: any }), extend?: (string | { [k: string]: any }), options?: { [k: string]: any }, comment?: string);
/** Field rule, if any. */
public rule?: string;
/** Field type. */
public type: string;
/** Unique field id. */
public id: number;
/** Extended type if different from parent. */
public extend?: string;
/** Whether this field is required. */
public required: boolean;
/** Whether this field is optional. */
public optional: boolean;
/** Whether this field is repeated. */
public repeated: boolean;
/** Whether this field is a map or not. */
public map: boolean;
/** Message this field belongs to. */
public message: (Type | null);
/** OneOf this field belongs to, if any, */
public partOf: (OneOf | null);
/** The field type's default value. */
public typeDefault: any;
/** The field's default value on prototypes. */
public defaultValue: any;
/** Whether this field's value should be treated as a long. */
public long: boolean;
/** Whether this field's value is a buffer. */
public bytes: boolean;
/** Resolved type if not a basic type. */
public resolvedType: (Type | Enum | null);
/** Sister-field within the extended type if a declaring extension field. */
public extensionField: (Field | null);
/** Sister-field within the declaring namespace if an extended field. */
public declaringField: (Field | null);
/** Comment for this field. */
public comment: (string | null);
/**
* Converts this field to a field descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Field descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IField;
/**
* Resolves this field's type references.
* @returns `this`
* @throws {Error} If any reference cannot be resolved
*/
public resolve(): Field;
}
/** Field descriptor. */
export interface IField {
/** Field rule */
rule?: string;
/** Field type */
type: string;
/** Field id */
id: number;
/** Field options */
options?: { [k: string]: any };
}
/** Extension field descriptor. */
export interface IExtensionField extends IField {
/** Extended type */
extend: string;
}
/**
* Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
* @param prototype Target prototype
* @param fieldName Field name
*/
type FieldDecorator = (prototype: object, fieldName: string) => void;
/**
* A node-style callback as used by {@link load} and {@link Root#load}.
* @param error Error, if any, otherwise `null`
* @param [root] Root, if there hasn't been an error
*/
type LoadCallback = (error: (Error | null), root?: Root) => void;
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
* @param filename One or multiple files to load
* @param root Root namespace, defaults to create a new one if omitted.
* @param callback Callback function
* @see {@link Root#load}
*/
export function load(filename: (string | string[]), root: Root, callback: LoadCallback): void;
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
* @param filename One or multiple files to load
* @param callback Callback function
* @see {@link Root#load}
*/
export function load(filename: (string | string[]), callback: LoadCallback): void;
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.
* @param filename One or multiple files to load
* @param [root] Root namespace, defaults to create a new one if omitted.
* @returns Promise
* @see {@link Root#load}
*/
export function load(filename: (string | string[]), root?: Root): Promise<Root>;
/**
* Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
* @param filename One or multiple files to load
* @param [root] Root namespace, defaults to create a new one if omitted.
* @returns Root namespace
* @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
* @see {@link Root#loadSync}
*/
export function loadSync(filename: (string | string[]), root?: Root): Root;
/** Build type, one of `"full"`, `"light"` or `"minimal"`. */
export const build: string;
/** Reconfigures the library according to the environment. */
export function configure(): void;
/** Reflected map field. */
export class MapField extends FieldBase {
/**
* Constructs a new map field instance.
* @param name Unique name within its namespace
* @param id Unique id within its namespace
* @param keyType Key type
* @param type Value type
* @param [options] Declared options
* @param [comment] Comment associated with this field
*/
constructor(name: string, id: number, keyType: string, type: string, options?: { [k: string]: any }, comment?: string);
/** Key type. */
public keyType: string;
/** Resolved key type if not a basic type. */
public resolvedKeyType: (ReflectionObject | null);
/**
* Constructs a map field from a map field descriptor.
* @param name Field name
* @param json Map field descriptor
* @returns Created map field
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IMapField): MapField;
/**
* Converts this map field to a map field descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Map field descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IMapField;
/**
* Map field decorator (TypeScript).
* @param fieldId Field id
* @param fieldKeyType Field key type
* @param fieldValueType Field value type
* @returns Decorator function
*/
public static d<T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }>(fieldId: number, fieldKeyType: ("int32" | "uint32" | "sint32" | "fixed32" | "sfixed32" | "int64" | "uint64" | "sint64" | "fixed64" | "sfixed64" | "bool" | "string"), fieldValueType: ("double" | "float" | "int32" | "uint32" | "sint32" | "fixed32" | "sfixed32" | "int64" | "uint64" | "sint64" | "fixed64" | "sfixed64" | "bool" | "string" | "bytes" | object | Constructor<{}>)): FieldDecorator;
}
/** Map field descriptor. */
export interface IMapField extends IField {
/** Key type */
keyType: string;
}
/** Extension map field descriptor. */
export interface IExtensionMapField extends IMapField {
/** Extended type */
extend: string;
}
/** Abstract runtime message. */
export class Message<T extends object = object> {
/**
* Constructs a new message instance.
* @param [properties] Properties to set
*/
constructor(properties?: Properties<T>);
/** Reference to the reflected type. */
public static readonly $type: Type;
/** Reference to the reflected type. */
public readonly $type: Type;
/**
* Creates a new message of this type using the specified properties.
* @param [properties] Properties to set
* @returns Message instance
*/
public static create<T extends Message<T>>(this: Constructor<T>, properties?: { [k: string]: any }): Message<T>;
/**
* Encodes a message of this type.
* @param message Message to encode
* @param [writer] Writer to use
* @returns Writer
*/
public static encode<T extends Message<T>>(this: Constructor<T>, message: (T | { [k: string]: any }), writer?: Writer): Writer;
/**
* Encodes a message of this type preceeded by its length as a varint.
* @param message Message to encode
* @param [writer] Writer to use
* @returns Writer
*/
public static encodeDelimited<T extends Message<T>>(this: Constructor<T>, message: (T | { [k: string]: any }), writer?: Writer): Writer;
/**
* Decodes a message of this type.
* @param reader Reader or buffer to decode
* @returns Decoded message
*/
public static decode<T extends Message<T>>(this: Constructor<T>, reader: (Reader | Uint8Array)): T;
/**
* Decodes a message of this type preceeded by its length as a varint.
* @param reader Reader or buffer to decode
* @returns Decoded message
*/
public static decodeDelimited<T extends Message<T>>(this: Constructor<T>, reader: (Reader | Uint8Array)): T;
/**
* Verifies a message of this type.
* @param message Plain object to verify
* @returns `null` if valid, otherwise the reason why it is not
*/
public static verify(message: { [k: string]: any }): (string | null);
/**
* Creates a new message of this type from a plain object. Also converts values to their respective internal types.
* @param object Plain object
* @returns Message instance
*/
public static fromObject<T extends Message<T>>(this: Constructor<T>, object: { [k: string]: any }): T;
/**
* Creates a plain object from a message of this type. Also converts values to other types if specified.
* @param message Message instance
* @param [options] Conversion options
* @returns Plain object
*/
public static toObject<T extends Message<T>>(this: Constructor<T>, message: T, options?: IConversionOptions): { [k: string]: any };
/**
* Converts this message to JSON.
* @returns JSON object
*/
public toJSON(): { [k: string]: any };
}
/** Reflected service method. */
export class Method extends ReflectionObject {
/**
* Constructs a new service method instance.
* @param name Method name
* @param type Method type, usually `"rpc"`
* @param requestType Request message type
* @param responseType Response message type
* @param [requestStream] Whether the request is streamed
* @param [responseStream] Whether the response is streamed
* @param [options] Declared options
* @param [comment] The comment for this method
*/
constructor(name: string, type: (string | undefined), requestType: string, responseType: string, requestStream?: (boolean | { [k: string]: any }), responseStream?: (boolean | { [k: string]: any }), options?: { [k: string]: any }, comment?: string);
/** Method type. */
public type: string;
/** Request type. */
public requestType: string;
/** Whether requests are streamed or not. */
public requestStream?: boolean;
/** Response type. */
public responseType: string;
/** Whether responses are streamed or not. */
public responseStream?: boolean;
/** Resolved request type. */
public resolvedRequestType: (Type | null);
/** Resolved response type. */
public resolvedResponseType: (Type | null);
/** Comment for this method */
public comment: (string | null);
/**
* Constructs a method from a method descriptor.
* @param name Method name
* @param json Method descriptor
* @returns Created method
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IMethod): Method;
/**
* Converts this method to a method descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Method descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IMethod;
}
/** Method descriptor. */
export interface IMethod {
/** Method type */
type?: string;
/** Request type */
requestType: string;
/** Response type */
responseType: string;
/** Whether requests are streamed */
requestStream?: boolean;
/** Whether responses are streamed */
responseStream?: boolean;
/** Method options */
options?: { [k: string]: any };
}
/** Reflected namespace. */
export class Namespace extends NamespaceBase {
/**
* Constructs a new namespace instance.
* @param name Namespace name
* @param [options] Declared options
*/
constructor(name: string, options?: { [k: string]: any });
/**
* Constructs a namespace from JSON.
* @param name Namespace name
* @param json JSON object
* @returns Created namespace
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: { [k: string]: any }): Namespace;
/**
* Converts an array of reflection objects to JSON.
* @param array Object array
* @param [toJSONOptions] JSON conversion options
* @returns JSON object or `undefined` when array is empty
*/
public static arrayToJSON(array: ReflectionObject[], toJSONOptions?: IToJSONOptions): ({ [k: string]: any } | undefined);
/**
* Tests if the specified id is reserved.
* @param reserved Array of reserved ranges and names
* @param id Id to test
* @returns `true` if reserved, otherwise `false`
*/
public static isReservedId(reserved: ((number[] | string)[] | undefined), id: number): boolean;
/**
* Tests if the specified name is reserved.
* @param reserved Array of reserved ranges and names
* @param name Name to test
* @returns `true` if reserved, otherwise `false`
*/
public static isReservedName(reserved: ((number[] | string)[] | undefined), name: string): boolean;
}
/** Base class of all reflection objects containing nested objects. This is not an actual class but here for the sake of having consistent type definitions. */
export abstract class NamespaceBase extends ReflectionObject {
/** Nested objects by name. */
public nested?: { [k: string]: ReflectionObject };
/** Nested objects of this namespace as an array for iteration. */
public readonly nestedArray: ReflectionObject[];
/**
* Converts this namespace to a namespace descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Namespace descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): INamespace;
/**
* Adds nested objects to this namespace from nested object descriptors.
* @param nestedJson Any nested object descriptors
* @returns `this`
*/
public addJSON(nestedJson: { [k: string]: AnyNestedObject }): Namespace;
/**
* Gets the nested object of the specified name.
* @param name Nested object name
* @returns The reflection object or `null` if it doesn't exist
*/
public get(name: string): (ReflectionObject | null);
/**
* Gets the values of the nested {@link Enum|enum} of the specified name.
* This methods differs from {@link Namespace#get|get} in that it returns an enum's values directly and throws instead of returning `null`.
* @param name Nested enum name
* @returns Enum values
* @throws {Error} If there is no such enum
*/
public getEnum(name: string): { [k: string]: number };
/**
* Adds a nested object to this namespace.
* @param object Nested object to add
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a nested object with this name
*/
public add(object: ReflectionObject): Namespace;
/**
* Removes a nested object from this namespace.
* @param object Nested object to remove
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `object` is not a member of this namespace
*/
public remove(object: ReflectionObject): Namespace;
/**
* Defines additial namespaces within this one if not yet existing.
* @param path Path to create
* @param [json] Nested types to create from JSON
* @returns Pointer to the last namespace created or `this` if path is empty
*/
public define(path: (string | string[]), json?: any): Namespace;
/**
* Resolves this namespace's and all its nested objects' type references. Useful to validate a reflection tree, but comes at a cost.
* @returns `this`
*/
public resolveAll(): Namespace;
/**
* Recursively looks up the reflection object matching the specified path in the scope of this namespace.
* @param path Path to look up
* @param filterTypes Filter types, any combination of the constructors of `protobuf.Type`, `protobuf.Enum`, `protobuf.Service` etc.
* @param [parentAlreadyChecked=false] If known, whether the parent has already been checked
* @returns Looked up object or `null` if none could be found
*/
public lookup(path: (string | string[]), filterTypes: (any | any[]), parentAlreadyChecked?: boolean): (ReflectionObject | null);
/**
* Looks up the reflection object at the specified path, relative to this namespace.
* @param path Path to look up
* @param [parentAlreadyChecked=false] Whether the parent has already been checked
* @returns Looked up object or `null` if none could be found
*/
public lookup(path: (string | string[]), parentAlreadyChecked?: boolean): (ReflectionObject | null);
/**
* Looks up the {@link Type|type} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param path Path to look up
* @returns Looked up type
* @throws {Error} If `path` does not point to a type
*/
public lookupType(path: (string | string[])): Type;
/**
* Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param path Path to look up
* @returns Looked up enum
* @throws {Error} If `path` does not point to an enum
*/
public lookupEnum(path: (string | string[])): Enum;
/**
* Looks up the {@link Type|type} or {@link Enum|enum} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param path Path to look up
* @returns Looked up type or enum
* @throws {Error} If `path` does not point to a type or enum
*/
public lookupTypeOrEnum(path: (string | string[])): Type;
/**
* Looks up the {@link Service|service} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param path Path to look up
* @returns Looked up service
* @throws {Error} If `path` does not point to a service
*/
public lookupService(path: (string | string[])): Service;
}
/** Namespace descriptor. */
export interface INamespace {
/** Namespace options */
options?: { [k: string]: any };
/** Nested object descriptors */
nested?: { [k: string]: AnyNestedObject };
}
/** Any extension field descriptor. */
type AnyExtensionField = (IExtensionField | IExtensionMapField);
/** Any nested object descriptor. */
type AnyNestedObject = (IEnum | IType | IService | AnyExtensionField | INamespace);
/** Base class of all reflection objects. */
export abstract class ReflectionObject {
/** Options. */
public options?: { [k: string]: any };
/** Parsed Options. */
public parsedOptions?: { [k: string]: any[] };
/** Unique name within its namespace. */
public name: string;
/** Parent namespace. */
public parent: (Namespace | null);
/** Whether already resolved or not. */
public resolved: boolean;
/** Comment text, if any. */
public comment: (string | null);
/** Defining file name. */
public filename: (string | null);
/** Reference to the root namespace. */
public readonly root: Root;
/** Full name including leading dot. */
public readonly fullName: string;
/**
* Converts this reflection object to its descriptor representation.
* @returns Descriptor
*/
public toJSON(): { [k: string]: any };
/**
* Called when this object is added to a parent.
* @param parent Parent added to
*/
public onAdd(parent: ReflectionObject): void;
/**
* Called when this object is removed from a parent.
* @param parent Parent removed from
*/
public onRemove(parent: ReflectionObject): void;
/**
* Resolves this objects type references.
* @returns `this`
*/
public resolve(): ReflectionObject;
/**
* Gets an option value.
* @param name Option name
* @returns Option value or `undefined` if not set
*/
public getOption(name: string): any;
/**
* Sets an option.
* @param name Option name
* @param value Option value
* @param [ifNotSet] Sets the option only if it isn't currently set
* @returns `this`
*/
public setOption(name: string, value: any, ifNotSet?: boolean): ReflectionObject;
/**
* Sets a parsed option.
* @param name parsed Option name
* @param value Option value
* @param propName dot '.' delimited full path of property within the option to set. if undefined\empty, will add a new option with that value
* @returns `this`
*/
public setParsedOption(name: string, value: any, propName: string): ReflectionObject;
/**
* Sets multiple options.
* @param options Options to set
* @param [ifNotSet] Sets an option only if it isn't currently set
* @returns `this`
*/
public setOptions(options: { [k: string]: any }, ifNotSet?: boolean): ReflectionObject;
/**
* Converts this instance to its string representation.
* @returns Class name[, space, full name]
*/
public toString(): string;
}
/** Reflected oneof. */
export class OneOf extends ReflectionObject {
/**
* Constructs a new oneof instance.
* @param name Oneof name
* @param [fieldNames] Field names
* @param [options] Declared options
* @param [comment] Comment associated with this field
*/
constructor(name: string, fieldNames?: (string[] | { [k: string]: any }), options?: { [k: string]: any }, comment?: string);
/** Field names that belong to this oneof. */
public oneof: string[];
/** Fields that belong to this oneof as an array for iteration. */
public readonly fieldsArray: Field[];
/** Comment for this field. */
public comment: (string | null);
/**
* Constructs a oneof from a oneof descriptor.
* @param name Oneof name
* @param json Oneof descriptor
* @returns Created oneof
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IOneOf): OneOf;
/**
* Converts this oneof to a oneof descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Oneof descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IOneOf;
/**
* Adds a field to this oneof and removes it from its current parent, if any.
* @param field Field to add
* @returns `this`
*/
public add(field: Field): OneOf;
/**
* Removes a field from this oneof and puts it back to the oneof's parent.
* @param field Field to remove
* @returns `this`
*/
public remove(field: Field): OneOf;
/**
* OneOf decorator (TypeScript).
* @param fieldNames Field names
* @returns Decorator function
*/
public static d<T extends string>(...fieldNames: string[]): OneOfDecorator;
}
/** Oneof descriptor. */
export interface IOneOf {
/** Oneof field names */
oneof: string[];
/** Oneof options */
options?: { [k: string]: any };
}
/**
* Decorator function as returned by {@link OneOf.d} (TypeScript).
* @param prototype Target prototype
* @param oneofName OneOf name
*/
type OneOfDecorator = (prototype: object, oneofName: string) => void;
/**
* Parses the given .proto source and returns an object with the parsed contents.
* @param source Source contents
* @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns Parser result
*/
export function parse(source: string, options?: IParseOptions): IParserResult;
/** Result object returned from {@link parse}. */
export interface IParserResult {
/** Package name, if declared */
package: (string | undefined);
/** Imports, if any */
imports: (string[] | undefined);
/** Weak imports, if any */
weakImports: (string[] | undefined);
/** Syntax, if specified (either `"proto2"` or `"proto3"`) */
syntax: (string | undefined);
/** Populated root instance */
root: Root;
}
/** Options modifying the behavior of {@link parse}. */
export interface IParseOptions {
/** Keeps field casing instead of converting to camel case */
keepCase?: boolean;
/** Recognize double-slash comments in addition to doc-block comments. */
alternateCommentMode?: boolean;
/** Use trailing comment when both leading comment and trailing comment exist. */
preferTrailingComment?: boolean;
}
/** Options modifying the behavior of JSON serialization. */
export interface IToJSONOptions {
/** Serializes comments. */
keepComments?: boolean;
}
/**
* Parses the given .proto source and returns an object with the parsed contents.
* @param source Source contents
* @param root Root to populate
* @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns Parser result
*/
export function parse(source: string, root: Root, options?: IParseOptions): IParserResult;
/** Wire format reader using `Uint8Array` if available, otherwise `Array`. */
export class Reader {
/**
* Constructs a new reader instance using the specified buffer.
* @param buffer Buffer to read from
*/
constructor(buffer: Uint8Array);
/** Read buffer. */
public buf: Uint8Array;
/** Read buffer position. */
public pos: number;
/** Read buffer length. */
public len: number;
/**
* Creates a new reader using the specified buffer.
* @param buffer Buffer to read from
* @returns A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
* @throws {Error} If `buffer` is not a valid buffer
*/
public static create(buffer: (Uint8Array | Buffer)): (Reader | BufferReader);
/**
* Reads a varint as an unsigned 32 bit value.
* @returns Value read
*/
public uint32(): number;
/**
* Reads a varint as a signed 32 bit value.
* @returns Value read
*/
public int32(): number;
/**
* Reads a zig-zag encoded varint as a signed 32 bit value.
* @returns Value read
*/
public sint32(): number;
/**
* Reads a varint as a signed 64 bit value.
* @returns Value read
*/
public int64(): Long;
/**
* Reads a varint as an unsigned 64 bit value.
* @returns Value read
*/
public uint64(): Long;
/**
* Reads a zig-zag encoded varint as a signed 64 bit value.
* @returns Value read
*/
public sint64(): Long;
/**
* Reads a varint as a boolean.
* @returns Value read
*/
public bool(): boolean;
/**
* Reads fixed 32 bits as an unsigned 32 bit integer.
* @returns Value read
*/
public fixed32(): number;
/**
* Reads fixed 32 bits as a signed 32 bit integer.
* @returns Value read
*/
public sfixed32(): number;
/**
* Reads fixed 64 bits.
* @returns Value read
*/
public fixed64(): Long;
/**
* Reads zig-zag encoded fixed 64 bits.
* @returns Value read
*/
public sfixed64(): Long;
/**
* Reads a float (32 bit) as a number.
* @returns Value read
*/
public float(): number;
/**
* Reads a double (64 bit float) as a number.
* @returns Value read
*/
public double(): number;
/**
* Reads a sequence of bytes preceeded by its length as a varint.
* @returns Value read
*/
public bytes(): Uint8Array;
/**
* Reads a string preceeded by its byte length as a varint.
* @returns Value read
*/
public string(): string;
/**
* Skips the specified number of bytes if specified, otherwise skips a varint.
* @param [length] Length if known, otherwise a varint is assumed
* @returns `this`
*/
public skip(length?: number): Reader;
/**
* Skips the next element of the specified wire type.
* @param wireType Wire type received
* @returns `this`
*/
public skipType(wireType: number): Reader;
}
/** Wire format reader using node buffers. */
export class BufferReader extends Reader {
/**
* Constructs a new buffer reader instance.
* @param buffer Buffer to read from
*/
constructor(buffer: Buffer);
/**
* Reads a sequence of bytes preceeded by its length as a varint.
* @returns Value read
*/
public bytes(): Buffer;
}
/** Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together. */
export class Root extends NamespaceBase {
/**
* Constructs a new root namespace instance.
* @param [options] Top level options
*/
constructor(options?: { [k: string]: any });
/** Deferred extension fields. */
public deferred: Field[];
/** Resolved file names of loaded files. */
public files: string[];
/**
* Loads a namespace descriptor into a root namespace.
* @param json Nameespace descriptor
* @param [root] Root namespace, defaults to create a new one if omitted
* @returns Root namespace
*/
public static fromJSON(json: INamespace, root?: Root): Root;
/**
* Resolves the path of an imported file, relative to the importing origin.
* This method exists so you can override it with your own logic in case your imports are scattered over multiple directories.
* @param origin The file name of the importing file
* @param target The file name being imported
* @returns Resolved path to `target` or `null` to skip the file
*/
public resolvePath(origin: string, target: string): (string | null);
/**
* Fetch content from file path or url
* This method exists so you can override it with your own logic.
* @param path File path or url
* @param callback Callback function
*/
public fetch(path: string, callback: FetchCallback): void;
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
* @param filename Names of one or multiple files to load
* @param options Parse options
* @param callback Callback function
*/
public load(filename: (string | string[]), options: IParseOptions, callback: LoadCallback): void;
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
* @param filename Names of one or multiple files to load
* @param callback Callback function
*/
public load(filename: (string | string[]), callback: LoadCallback): void;
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and returns a promise.
* @param filename Names of one or multiple files to load
* @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns Promise
*/
public load(filename: (string | string[]), options?: IParseOptions): Promise<Root>;
/**
* Synchronously loads one or multiple .proto or preprocessed .json files into this root namespace (node only).
* @param filename Names of one or multiple files to load
* @param [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns Root namespace
* @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
*/
public loadSync(filename: (string | string[]), options?: IParseOptions): Root;
}
/**
* Named roots.
* This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
* Can also be used manually to make roots available accross modules.
*/
export let roots: { [k: string]: Root };
/** Streaming RPC helpers. */
export namespace rpc {
/**
* A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
*
* Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
* @param error Error, if any
* @param [response] Response message
*/
type ServiceMethodCallback<TRes extends Message<TRes>> = (error: (Error | null), response?: TRes) => void;
/**
* A service method part of a {@link rpc.Service} as created by {@link Service.create}.
* @param request Request message or plain object
* @param [callback] Node-style callback called with the error, if any, and the response message
* @returns Promise if `callback` has been omitted, otherwise `undefined`
*/
type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = (request: (TReq | Properties<TReq>), callback?: rpc.ServiceMethodCallback<TRes>) => Promise<Message<TRes>>;
/** An RPC service as returned by {@link Service#create}. */
class Service extends util.EventEmitter {
/**
* Constructs a new RPC service instance.
* @param rpcImpl RPC implementation
* @param [requestDelimited=false] Whether requests are length-delimited
* @param [responseDelimited=false] Whether responses are length-delimited
*/
constructor(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
/** RPC implementation. Becomes `null` once the service is ended. */
public rpcImpl: (RPCImpl | null);
/** Whether requests are length-delimited. */
public requestDelimited: boolean;
/** Whether responses are length-delimited. */
public responseDelimited: boolean;
/**
* Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
* @param method Reflected or static method
* @param requestCtor Request constructor
* @param responseCtor Response constructor
* @param request Request message or plain object
* @param callback Service callback
*/
public rpcCall<TReq extends Message<TReq>, TRes extends Message<TRes>>(method: (Method | rpc.ServiceMethod<TReq, TRes>), requestCtor: Constructor<TReq>, responseCtor: Constructor<TRes>, request: (TReq | Properties<TReq>), callback: rpc.ServiceMethodCallback<TRes>): void;
/**
* Ends this service and emits the `end` event.
* @param [endedByRPC=false] Whether the service has been ended by the RPC implementation.
* @returns `this`
*/
public end(endedByRPC?: boolean): rpc.Service;
}
}
/**
* RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
* @param method Reflected or static method being called
* @param requestData Request data
* @param callback Callback function
*/
type RPCImpl = (method: (Method | rpc.ServiceMethod<Message<{}>, Message<{}>>), requestData: Uint8Array, callback: RPCImplCallback) => void;
/**
* Node-style callback as used by {@link RPCImpl}.
* @param error Error, if any, otherwise `null`
* @param [response] Response data or `null` to signal end of stream, if there hasn't been an error
*/
type RPCImplCallback = (error: (Error | null), response?: (Uint8Array | null)) => void;
/** Reflected service. */
export class Service extends NamespaceBase {
/**
* Constructs a new service instance.
* @param name Service name
* @param [options] Service options
* @throws {TypeError} If arguments are invalid
*/
constructor(name: string, options?: { [k: string]: any });
/** Service methods. */
public methods: { [k: string]: Method };
/**
* Constructs a service from a service descriptor.
* @param name Service name
* @param json Service descriptor
* @returns Created service
* @throws {TypeError} If arguments are invalid
*/
public static fromJSON(name: string, json: IService): Service;
/**
* Converts this service to a service descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Service descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IService;
/** Methods of this service as an array for iteration. */
public readonly methodsArray: Method[];
/**
* Creates a runtime service using the specified rpc implementation.
* @param rpcImpl RPC implementation
* @param [requestDelimited=false] Whether requests are length-delimited
* @param [responseDelimited=false] Whether responses are length-delimited
* @returns RPC service. Useful where requests and/or responses are streamed.
*/
public create(rpcImpl: RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean): rpc.Service;
}
/** Service descriptor. */
export interface IService extends INamespace {
/** Method descriptors */
methods: { [k: string]: IMethod };
}
/**
* Gets the next token and advances.
* @returns Next token or `null` on eof
*/
type TokenizerHandleNext = () => (string | null);
/**
* Peeks for the next token.
* @returns Next token or `null` on eof
*/
type TokenizerHandlePeek = () => (string | null);
/**
* Pushes a token back to the stack.
* @param token Token
*/
type TokenizerHandlePush = (token: string) => void;
/**
* Skips the next token.
* @param expected Expected token
* @param [optional=false] If optional
* @returns Whether the token matched
* @throws {Error} If the token didn't match and is not optional
*/
type TokenizerHandleSkip = (expected: string, optional?: boolean) => boolean;
/**
* Gets the comment on the previous line or, alternatively, the line comment on the specified line.
* @param [line] Line number
* @returns Comment text or `null` if none
*/
type TokenizerHandleCmnt = (line?: number) => (string | null);
/** Handle object returned from {@link tokenize}. */
export interface ITokenizerHandle {
/** Gets the next token and advances (`null` on eof) */
next: TokenizerHandleNext;
/** Peeks for the next token (`null` on eof) */
peek: TokenizerHandlePeek;
/** Pushes a token back to the stack */
push: TokenizerHandlePush;
/** Skips a token, returns its presence and advances or, if non-optional and not present, throws */
skip: TokenizerHandleSkip;
/** Gets the comment on the previous line or the line comment on the specified line, if any */
cmnt: TokenizerHandleCmnt;
/** Current line number */
line: number;
}
/**
* Tokenizes the given .proto source and returns an object with useful utility functions.
* @param source Source contents
* @param alternateCommentMode Whether we should activate alternate comment parsing mode.
* @returns Tokenizer handle
*/
export function tokenize(source: string, alternateCommentMode: boolean): ITokenizerHandle;
export namespace tokenize {
/**
* Unescapes a string.
* @param str String to unescape
* @returns Unescaped string
*/
function unescape(str: string): string;
}
/** Reflected message type. */
export class Type extends NamespaceBase {
/**
* Constructs a new reflected message type instance.
* @param name Message name
* @param [options] Declared options
*/
constructor(name: string, options?: { [k: string]: any });
/** Message fields. */
public fields: { [k: string]: Field };
/** Oneofs declared within this namespace, if any. */
public oneofs: { [k: string]: OneOf };
/** Extension ranges, if any. */
public extensions: number[][];
/** Reserved ranges, if any. */
public reserved: (number[] | string)[];
/** Message fields by id. */
public readonly fieldsById: { [k: number]: Field };
/** Fields of this message as an array for iteration. */
public readonly fieldsArray: Field[];
/** Oneofs of this message as an array for iteration. */
public readonly oneofsArray: OneOf[];
/**
* The registered constructor, if any registered, otherwise a generic constructor.
* Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
*/
public ctor: Constructor<{}>;
/**
* Generates a constructor function for the specified type.
* @param mtype Message type
* @returns Codegen instance
*/
public static generateConstructor(mtype: Type): Codegen;
/**
* Creates a message type from a message type descriptor.
* @param name Message name
* @param json Message type descriptor
* @returns Created message type
*/
public static fromJSON(name: string, json: IType): Type;
/**
* Converts this message type to a message type descriptor.
* @param [toJSONOptions] JSON conversion options
* @returns Message type descriptor
*/
public toJSON(toJSONOptions?: IToJSONOptions): IType;
/**
* Adds a nested object to this type.
* @param object Nested object to add
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a nested object with this name or, if a field, when there is already a field with this id
*/
public add(object: ReflectionObject): Type;
/**
* Removes a nested object from this type.
* @param object Nested object to remove
* @returns `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `object` is not a member of this type
*/
public remove(object: ReflectionObject): Type;
/**
* Tests if the specified id is reserved.
* @param id Id to test
* @returns `true` if reserved, otherwise `false`
*/
public isReservedId(id: number): boolean;
/**
* Tests if the specified name is reserved.
* @param name Name to test
* @returns `true` if reserved, otherwise `false`
*/
public isReservedName(name: string): boolean;
/**
* Creates a new message of this type using the specified properties.
* @param [properties] Properties to set
* @returns Message instance
*/
public create(properties?: { [k: string]: any }): Message<{}>;
/**
* Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.
* @returns `this`
*/
public setup(): Type;
/**
* Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.
* @param message Message instance or plain object
* @param [writer] Writer to encode to
* @returns writer
*/
public encode(message: (Message<{}> | { [k: string]: any }), writer?: Writer): Writer;
/**
* Encodes a message of this type preceeded by its byte length as a varint. Does not implicitly {@link Type#verify|verify} messages.
* @param message Message instance or plain object
* @param [writer] Writer to encode to
* @returns writer
*/
public encodeDelimited(message: (Message<{}> | { [k: string]: any }), writer?: Writer): Writer;
/**
* Decodes a message of this type.
* @param reader Reader or buffer to decode from
* @param [length] Length of the message, if known beforehand
* @returns Decoded message
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {util.ProtocolError<{}>} If required fields are missing
*/
public decode(reader: (Reader | Uint8Array), length?: number): Message<{}>;
/**
* Decodes a message of this type preceeded by its byte length as a varint.
* @param reader Reader or buffer to decode from
* @returns Decoded message
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {util.ProtocolError} If required fields are missing
*/
public decodeDelimited(reader: (Reader | Uint8Array)): Message<{}>;
/**
* Verifies that field values are valid and that required fields are present.
* @param message Plain object to verify
* @returns `null` if valid, otherwise the reason why it is not
*/
public verify(message: { [k: string]: any }): (null | string);
/**
* Creates a new message of this type from a plain object. Also converts values to their respective internal types.
* @param object Plain object to convert
* @returns Message instance
*/
public fromObject(object: { [k: string]: any }): Message<{}>;
/**
* Creates a plain object from a message of this type. Also converts values to other types if specified.
* @param message Message instance
* @param [options] Conversion options
* @returns Plain object
*/
public toObject(message: Message<{}>, options?: IConversionOptions): { [k: string]: any };
/**
* Type decorator (TypeScript).
* @param [typeName] Type name, defaults to the constructor's name
* @returns Decorator function
*/
public static d<T extends Message<T>>(typeName?: string): TypeDecorator<T>;
}
/** Message type descriptor. */
export interface IType extends INamespace {
/** Oneof descriptors */
oneofs?: { [k: string]: IOneOf };
/** Field descriptors */
fields: { [k: string]: IField };
/** Extension ranges */
extensions?: number[][];
/** Reserved ranges */
reserved?: number[][];
/** Whether a legacy group or not */
group?: boolean;
}
/** Conversion options as used by {@link Type#toObject} and {@link Message.toObject}. */
export interface IConversionOptions {
/**
* Long conversion type.
* Valid values are `String` and `Number` (the global types).
* Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.
*/
longs?: Function;
/**
* Enum value conversion type.
* Only valid value is `String` (the global type).
* Defaults to copy the present value, which is the numeric id.
*/
enums?: Function;
/**
* Bytes value conversion type.
* Valid values are `Array` and (a base64 encoded) `String` (the global types).
* Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.
*/
bytes?: Function;
/** Also sets default values on the resulting object */
defaults?: boolean;
/** Sets empty arrays for missing repeated fields even if `defaults=false` */
arrays?: boolean;
/** Sets empty objects for missing map fields even if `defaults=false` */
objects?: boolean;
/** Includes virtual oneof properties set to the present field's name, if any */
oneofs?: boolean;
/** Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings */
json?: boolean;
}
/**
* Decorator function as returned by {@link Type.d} (TypeScript).
* @param target Target constructor
*/
type TypeDecorator<T extends Message<T>> = (target: Constructor<T>) => void;
/** Common type constants. */
export namespace types {
/** Basic type wire types. */
const basic: {
"double": number,
"float": number,
"int32": number,
"uint32": number,
"sint32": number,
"fixed32": number,
"sfixed32": number,
"int64": number,
"uint64": number,
"sint64": number,
"fixed64": number,
"sfixed64": number,
"bool": number,
"string": number,
"bytes": number
};
/** Basic type defaults. */
const defaults: {
"double": number,
"float": number,
"int32": number,
"uint32": number,
"sint32": number,
"fixed32": number,
"sfixed32": number,
"int64": number,
"uint64": number,
"sint64": number,
"fixed64": number,
"sfixed64": number,
"bool": boolean,
"string": string,
"bytes": number[],
"message": null
};
/** Basic long type wire types. */
const long: {
"int64": number,
"uint64": number,
"sint64": number,
"fixed64": number,
"sfixed64": number
};
/** Allowed types for map keys with their associated wire type. */
const mapKey: {
"int32": number,
"uint32": number,
"sint32": number,
"fixed32": number,
"sfixed32": number,
"int64": number,
"uint64": number,
"sint64": number,
"fixed64": number,
"sfixed64": number,
"bool": number,
"string": number
};
/** Allowed types for packed repeated fields with their associated wire type. */
const packed: {
"double": number,
"float": number,
"int32": number,
"uint32": number,
"sint32": number,
"fixed32": number,
"sfixed32": number,
"int64": number,
"uint64": number,
"sint64": number,
"fixed64": number,
"sfixed64": number,
"bool": number
};
}
/** Constructor type. */
export interface Constructor<T> extends Function {
new(...params: any[]): T; prototype: T;
}
/** Properties type. */
type Properties<T> = { [P in keyof T]?: T[P] };
/**
* Any compatible Buffer instance.
* This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
*/
export interface Buffer extends Uint8Array {
}
/**
* Any compatible Long instance.
* This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
*/
export interface Long {
/** Low bits */
low: number;
/** High bits */
high: number;
/** Whether unsigned or not */
unsigned: boolean;
}
/**
* A OneOf getter as returned by {@link util.oneOfGetter}.
* @returns Set field name, if any
*/
type OneOfGetter = () => (string | undefined);
/**
* A OneOf setter as returned by {@link util.oneOfSetter}.
* @param value Field name
*/
type OneOfSetter = (value: (string | undefined)) => void;
/** Various utility functions. */
export namespace util {
/** Helper class for working with the low and high bits of a 64 bit value. */
class LongBits {
/**
* Constructs new long bits.
* @param lo Low 32 bits, unsigned
* @param hi High 32 bits, unsigned
*/
constructor(lo: number, hi: number);
/** Low bits. */
public lo: number;
/** High bits. */
public hi: number;
/** Zero bits. */
public static zero: util.LongBits;
/** Zero hash. */
public static zeroHash: string;
/**
* Constructs new long bits from the specified number.
* @param value Value
* @returns Instance
*/
public static fromNumber(value: number): util.LongBits;
/**
* Constructs new long bits from a number, long or string.
* @param value Value
* @returns Instance
*/
public static from(value: (Long | number | string)): util.LongBits;
/**
* Converts this long bits to a possibly unsafe JavaScript number.
* @param [unsigned=false] Whether unsigned or not
* @returns Possibly unsafe number
*/
public toNumber(unsigned?: boolean): number;
/**
* Converts this long bits to a long.
* @param [unsigned=false] Whether unsigned or not
* @returns Long
*/
public toLong(unsigned?: boolean): Long;
/**
* Constructs new long bits from the specified 8 characters long hash.
* @param hash Hash
* @returns Bits
*/
public static fromHash(hash: string): util.LongBits;
/**
* Converts this long bits to a 8 characters long hash.
* @returns Hash
*/
public toHash(): string;
/**
* Zig-zag encodes this long bits.
* @returns `this`
*/
public zzEncode(): util.LongBits;
/**
* Zig-zag decodes this long bits.
* @returns `this`
*/
public zzDecode(): util.LongBits;
/**
* Calculates the length of this longbits when encoded as a varint.
* @returns Length
*/
public length(): number;
}
/** Whether running within node or not. */
let isNode: boolean;
/** Global object reference. */
let global: object;
/** An immuable empty array. */
const emptyArray: any[];
/** An immutable empty object. */
const emptyObject: object;
/**
* Tests if the specified value is an integer.
* @param value Value to test
* @returns `true` if the value is an integer
*/
function isInteger(value: any): boolean;
/**
* Tests if the specified value is a string.
* @param value Value to test
* @returns `true` if the value is a string
*/
function isString(value: any): boolean;
/**
* Tests if the specified value is a non-null object.
* @param value Value to test
* @returns `true` if the value is a non-null object
*/
function isObject(value: any): boolean;
/**
* Checks if a property on a message is considered to be present.
* This is an alias of {@link util.isSet}.
* @param obj Plain object or message instance
* @param prop Property name
* @returns `true` if considered to be present, otherwise `false`
*/
function isset(obj: object, prop: string): boolean;
/**
* Checks if a property on a message is considered to be present.
* @param obj Plain object or message instance
* @param prop Property name
* @returns `true` if considered to be present, otherwise `false`
*/
function isSet(obj: object, prop: string): boolean;
/** Node's Buffer class if available. */
let Buffer: Constructor<Buffer>;
/**
* Creates a new buffer of whatever type supported by the environment.
* @param [sizeOrArray=0] Buffer size or number array
* @returns Buffer
*/
function newBuffer(sizeOrArray?: (number | number[])): (Uint8Array | Buffer);
/** Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`. */
let Array: Constructor<Uint8Array>;
/** Long.js's Long class if available. */
let Long: Constructor<Long>;
/** Regular expression used to verify 2 bit (`bool`) map keys. */
const key2Re: RegExp;
/** Regular expression used to verify 32 bit (`int32` etc.) map keys. */
const key32Re: RegExp;
/** Regular expression used to verify 64 bit (`int64` etc.) map keys. */
const key64Re: RegExp;
/**
* Converts a number or long to an 8 characters long hash string.
* @param value Value to convert
* @returns Hash
*/
function longToHash(value: (Long | number)): string;
/**
* Converts an 8 characters long hash string to a long or number.
* @param hash Hash
* @param [unsigned=false] Whether unsigned or not
* @returns Original value
*/
function longFromHash(hash: string, unsigned?: boolean): (Long | number);
/**
* Merges the properties of the source object into the destination object.
* @param dst Destination object
* @param src Source object
* @param [ifNotSet=false] Merges only if the key is not already set
* @returns Destination object
*/
function merge(dst: { [k: string]: any }, src: { [k: string]: any }, ifNotSet?: boolean): { [k: string]: any };
/**
* Converts the first character of a string to lower case.
* @param str String to convert
* @returns Converted string
*/
function lcFirst(str: string): string;
/**
* Creates a custom error constructor.
* @param name Error name
* @returns Custom error constructor
*/
function newError(name: string): Constructor<Error>;
/** Error subclass indicating a protocol specifc error. */
class ProtocolError<T extends Message<T>> extends Error {
/**
* Constructs a new protocol error.
* @param message Error message
* @param [properties] Additional properties
*/
constructor(message: string, properties?: { [k: string]: any });
/** So far decoded message instance. */
public instance: Message<T>;
}
/**
* Builds a getter for a oneof's present field name.
* @param fieldNames Field names
* @returns Unbound getter
*/
function oneOfGetter(fieldNames: string[]): OneOfGetter;
/**
* Builds a setter for a oneof's present field name.
* @param fieldNames Field names
* @returns Unbound setter
*/
function oneOfSetter(fieldNames: string[]): OneOfSetter;
/**
* Default conversion options used for {@link Message#toJSON} implementations.
*
* These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
*
* - Longs become strings
* - Enums become string keys
* - Bytes become base64 encoded strings
* - (Sub-)Messages become plain objects
* - Maps become plain objects with all string keys
* - Repeated fields become arrays
* - NaN and Infinity for float and double fields become strings
*
* @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
*/
let toJSONOptions: IConversionOptions;
/** Node's fs module if available. */
let fs: { [k: string]: any };
/**
* Converts an object's values to an array.
* @param object Object to convert
* @returns Converted array
*/
function toArray(object: { [k: string]: any }): any[];
/**
* Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.
* @param array Array to convert
* @returns Converted object
*/
function toObject(array: any[]): { [k: string]: any };
/**
* Tests whether the specified name is a reserved word in JS.
* @param name Name to test
* @returns `true` if reserved, otherwise `false`
*/
function isReserved(name: string): boolean;
/**
* Returns a safe property accessor for the specified property name.
* @param prop Property name
* @returns Safe accessor
*/
function safeProp(prop: string): string;
/**
* Converts the first character of a string to upper case.
* @param str String to convert
* @returns Converted string
*/
function ucFirst(str: string): string;
/**
* Converts a string to camel case.
* @param str String to convert
* @returns Converted string
*/
function camelCase(str: string): string;
/**
* Compares reflected fields by id.
* @param a First field
* @param b Second field
* @returns Comparison value
*/
function compareFieldsById(a: Field, b: Field): number;
/**
* Decorator helper for types (TypeScript).
* @param ctor Constructor function
* @param [typeName] Type name, defaults to the constructor's name
* @returns Reflected type
*/
function decorateType<T extends Message<T>>(ctor: Constructor<T>, typeName?: string): Type;
/**
* Decorator helper for enums (TypeScript).
* @param object Enum object
* @returns Reflected enum
*/
function decorateEnum(object: object): Enum;
/**
* Sets the value of a property by property path. If a value already exists, it is turned to an array
* @param dst Destination object
* @param path dot '.' delimited path of the property to set
* @param value the value to set
* @returns Destination object
*/
function setProperty(dst: { [k: string]: any }, path: string, value: object): { [k: string]: any };
/** Decorator root (TypeScript). */
let decorateRoot: Root;
/**
* Returns a promise from a node-style callback function.
* @param fn Function to call
* @param ctx Function context
* @param params Function arguments
* @returns Promisified function
*/
function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
/** A minimal base64 implementation for number arrays. */
namespace base64 {
/**
* Calculates the byte length of a base64 encoded string.
* @param string Base64 encoded string
* @returns Byte length
*/
function length(string: string): number;
/**
* Encodes a buffer to a base64 encoded string.
* @param buffer Source buffer
* @param start Source start
* @param end Source end
* @returns Base64 encoded string
*/
function encode(buffer: Uint8Array, start: number, end: number): string;
/**
* Decodes a base64 encoded string to a buffer.
* @param string Source string
* @param buffer Destination buffer
* @param offset Destination offset
* @returns Number of bytes written
* @throws {Error} If encoding is invalid
*/
function decode(string: string, buffer: Uint8Array, offset: number): number;
/**
* Tests if the specified string appears to be base64 encoded.
* @param string String to test
* @returns `true` if probably base64 encoded, otherwise false
*/
function test(string: string): boolean;
}
/**
* Begins generating a function.
* @param functionParams Function parameter names
* @param [functionName] Function name if not anonymous
* @returns Appender that appends code to the function's body
*/
function codegen(functionParams: string[], functionName?: string): Codegen;
namespace codegen {
/** When set to `true`, codegen will log generated code to console. Useful for debugging. */
let verbose: boolean;
}
/**
* Begins generating a function.
* @param [functionName] Function name if not anonymous
* @returns Appender that appends code to the function's body
*/
function codegen(functionName?: string): Codegen;
/** A minimal event emitter. */
class EventEmitter {
/** Constructs a new event emitter instance. */
constructor();
/**
* Registers an event listener.
* @param evt Event name
* @param fn Listener
* @param [ctx] Listener context
* @returns `this`
*/
public on(evt: string, fn: EventEmitterListener, ctx?: any): this;
/**
* Removes an event listener or any matching listeners if arguments are omitted.
* @param [evt] Event name. Removes all listeners if omitted.
* @param [fn] Listener to remove. Removes all listeners of `evt` if omitted.
* @returns `this`
*/
public off(evt?: string, fn?: EventEmitterListener): this;
/**
* Emits an event by calling its listeners with the specified arguments.
* @param evt Event name
* @param args Arguments
* @returns `this`
*/
public emit(evt: string, ...args: any[]): this;
}
/** Reads / writes floats / doubles from / to buffers. */
namespace float {
/**
* Writes a 32 bit float to a buffer using little endian byte order.
* @param val Value to write
* @param buf Target buffer
* @param pos Target buffer offset
*/
function writeFloatLE(val: number, buf: Uint8Array, pos: number): void;
/**
* Writes a 32 bit float to a buffer using big endian byte order.
* @param val Value to write
* @param buf Target buffer
* @param pos Target buffer offset
*/
function writeFloatBE(val: number, buf: Uint8Array, pos: number): void;
/**
* Reads a 32 bit float from a buffer using little endian byte order.
* @param buf Source buffer
* @param pos Source buffer offset
* @returns Value read
*/
function readFloatLE(buf: Uint8Array, pos: number): number;
/**
* Reads a 32 bit float from a buffer using big endian byte order.
* @param buf Source buffer
* @param pos Source buffer offset
* @returns Value read
*/
function readFloatBE(buf: Uint8Array, pos: number): number;
/**
* Writes a 64 bit double to a buffer using little endian byte order.
* @param val Value to write
* @param buf Target buffer
* @param pos Target buffer offset
*/
function writeDoubleLE(val: number, buf: Uint8Array, pos: number): void;
/**
* Writes a 64 bit double to a buffer using big endian byte order.
* @param val Value to write
* @param buf Target buffer
* @param pos Target buffer offset
*/
function writeDoubleBE(val: number, buf: Uint8Array, pos: number): void;
/**
* Reads a 64 bit double from a buffer using little endian byte order.
* @param buf Source buffer
* @param pos Source buffer offset
* @returns Value read
*/
function readDoubleLE(buf: Uint8Array, pos: number): number;
/**
* Reads a 64 bit double from a buffer using big endian byte order.
* @param buf Source buffer
* @param pos Source buffer offset
* @returns Value read
*/
function readDoubleBE(buf: Uint8Array, pos: number): number;
}
/**
* Fetches the contents of a file.
* @param filename File path or url
* @param options Fetch options
* @param callback Callback function
*/
function fetch(filename: string, options: IFetchOptions, callback: FetchCallback): void;
/**
* Fetches the contents of a file.
* @param path File path or url
* @param callback Callback function
*/
function fetch(path: string, callback: FetchCallback): void;
/**
* Fetches the contents of a file.
* @param path File path or url
* @param [options] Fetch options
* @returns Promise
*/
function fetch(path: string, options?: IFetchOptions): Promise<(string | Uint8Array)>;
/**
* Requires a module only if available.
* @param moduleName Module to require
* @returns Required module if available and not empty, otherwise `null`
*/
function inquire(moduleName: string): object;
/** A minimal path module to resolve Unix, Windows and URL paths alike. */
namespace path {
/**
* Tests if the specified path is absolute.
* @param path Path to test
* @returns `true` if path is absolute
*/
function isAbsolute(path: string): boolean;
/**
* Normalizes the specified path.
* @param path Path to normalize
* @returns Normalized path
*/
function normalize(path: string): string;
/**
* Resolves the specified include path against the specified origin path.
* @param originPath Path to the origin file
* @param includePath Include path relative to origin path
* @param [alreadyNormalized=false] `true` if both paths are already known to be normalized
* @returns Path to the include file
*/
function resolve(originPath: string, includePath: string, alreadyNormalized?: boolean): string;
}
/**
* A general purpose buffer pool.
* @param alloc Allocator
* @param slice Slicer
* @param [size=8192] Slab size
* @returns Pooled allocator
*/
function pool(alloc: PoolAllocator, slice: PoolSlicer, size?: number): PoolAllocator;
/** A minimal UTF8 implementation for number arrays. */
namespace utf8 {
/**
* Calculates the UTF8 byte length of a string.
* @param string String
* @returns Byte length
*/
function length(string: string): number;
/**
* Reads UTF8 bytes as a string.
* @param buffer Source buffer
* @param start Source start
* @param end Source end
* @returns String read
*/
function read(buffer: Uint8Array, start: number, end: number): string;
/**
* Writes a string as UTF8 bytes.
* @param string Source string
* @param buffer Destination buffer
* @param offset Destination offset
* @returns Bytes written
*/
function write(string: string, buffer: Uint8Array, offset: number): number;
}
}
/**
* Generates a verifier specific to the specified message type.
* @param mtype Message type
* @returns Codegen instance
*/
export function verifier(mtype: Type): Codegen;
/** Wrappers for common types. */
export const wrappers: { [k: string]: IWrapper };
/**
* From object converter part of an {@link IWrapper}.
* @param object Plain object
* @returns Message instance
*/
type WrapperFromObjectConverter = (this: Type, object: { [k: string]: any }) => Message<{}>;
/**
* To object converter part of an {@link IWrapper}.
* @param message Message instance
* @param [options] Conversion options
* @returns Plain object
*/
type WrapperToObjectConverter = (this: Type, message: Message<{}>, options?: IConversionOptions) => { [k: string]: any };
/** Common type wrapper part of {@link wrappers}. */
export interface IWrapper {
/** From object converter */
fromObject?: WrapperFromObjectConverter;
/** To object converter */
toObject?: WrapperToObjectConverter;
}
/** Wire format writer using `Uint8Array` if available, otherwise `Array`. */
export class Writer {
/** Constructs a new writer instance. */
constructor();
/** Current length. */
public len: number;
/** Operations head. */
public head: object;
/** Operations tail */
public tail: object;
/** Linked forked states. */
public states: (object | null);
/**
* Creates a new writer.
* @returns A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
*/
public static create(): (BufferWriter | Writer);
/**
* Allocates a buffer of the specified size.
* @param size Buffer size
* @returns Buffer
*/
public static alloc(size: number): Uint8Array;
/**
* Writes an unsigned 32 bit value as a varint.
* @param value Value to write
* @returns `this`
*/
public uint32(value: number): Writer;
/**
* Writes a signed 32 bit value as a varint.
* @param value Value to write
* @returns `this`
*/
public int32(value: number): Writer;
/**
* Writes a 32 bit value as a varint, zig-zag encoded.
* @param value Value to write
* @returns `this`
*/
public sint32(value: number): Writer;
/**
* Writes an unsigned 64 bit value as a varint.
* @param value Value to write
* @returns `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
public uint64(value: (Long | number | string)): Writer;
/**
* Writes a signed 64 bit value as a varint.
* @param value Value to write
* @returns `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
public int64(value: (Long | number | string)): Writer;
/**
* Writes a signed 64 bit value as a varint, zig-zag encoded.
* @param value Value to write
* @returns `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
public sint64(value: (Long | number | string)): Writer;
/**
* Writes a boolish value as a varint.
* @param value Value to write
* @returns `this`
*/
public bool(value: boolean): Writer;
/**
* Writes an unsigned 32 bit value as fixed 32 bits.
* @param value Value to write
* @returns `this`
*/
public fixed32(value: number): Writer;
/**
* Writes a signed 32 bit value as fixed 32 bits.
* @param value Value to write
* @returns `this`
*/
public sfixed32(value: number): Writer;
/**
* Writes an unsigned 64 bit value as fixed 64 bits.
* @param value Value to write
* @returns `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
public fixed64(value: (Long | number | string)): Writer;
/**
* Writes a signed 64 bit value as fixed 64 bits.
* @param value Value to write
* @returns `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
public sfixed64(value: (Long | number | string)): Writer;
/**
* Writes a float (32 bit).
* @param value Value to write
* @returns `this`
*/
public float(value: number): Writer;
/**
* Writes a double (64 bit float).
* @param value Value to write
* @returns `this`
*/
public double(value: number): Writer;
/**
* Writes a sequence of bytes.
* @param value Buffer or base64 encoded string to write
* @returns `this`
*/
public bytes(value: (Uint8Array | string)): Writer;
/**
* Writes a string.
* @param value Value to write
* @returns `this`
*/
public string(value: string): Writer;
/**
* Forks this writer's state by pushing it to a stack.
* Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
* @returns `this`
*/
public fork(): Writer;
/**
* Resets this instance to the last state.
* @returns `this`
*/
public reset(): Writer;
/**
* Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
* @returns `this`
*/
public ldelim(): Writer;
/**
* Finishes the write operation.
* @returns Finished buffer
*/
public finish(): Uint8Array;
}
/** Wire format writer using node buffers. */
export class BufferWriter extends Writer {
/** Constructs a new buffer writer instance. */
constructor();
/**
* Allocates a buffer of the specified size.
* @param size Buffer size
* @returns Buffer
*/
public static alloc(size: number): Buffer;
/**
* Finishes the write operation.
* @returns Finished buffer
*/
public finish(): Buffer;
}
/**
* Callback as used by {@link util.asPromise}.
* @param error Error, if any
* @param params Additional arguments
*/
type asPromiseCallback = (error: (Error | null), ...params: any[]) => void;
/**
* Appends code to the function's body or finishes generation.
* @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
* @param [formatParams] Format parameters
* @returns Itself or the generated function if finished
* @throws {Error} If format parameter counts do not match
*/
type Codegen = (formatStringOrScope?: (string | { [k: string]: any }), ...formatParams: any[]) => (Codegen | Function);
/**
* Event listener as used by {@link util.EventEmitter}.
* @param args Arguments
*/
type EventEmitterListener = (...args: any[]) => void;
/**
* Node-style callback as used by {@link util.fetch}.
* @param error Error, if any, otherwise `null`
* @param [contents] File contents, if there hasn't been an error
*/
type FetchCallback = (error: Error, contents?: string) => void;
/** Options as used by {@link util.fetch}. */
export interface IFetchOptions {
/** Whether expecting a binary response */
binary?: boolean;
/** If `true`, forces the use of XMLHttpRequest */
xhr?: boolean;
}
/**
* An allocator as used by {@link util.pool}.
* @param size Buffer size
* @returns Buffer
*/
type PoolAllocator = (size: number) => Uint8Array;
/**
* A slicer as used by {@link util.pool}.
* @param start Start offset
* @param end End offset
* @returns Buffer slice
*/
type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手