Latest
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731// deno-lint-ignore-file// 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 };
/** 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;