mirror of
https://github.com/NapNeko/NapCatQQ.git
synced 2024-11-21 09:36:35 +00:00
436 lines
19 KiB
TypeScript
436 lines
19 KiB
TypeScript
// @generated by protobuf-ts 2.9.4
|
|
// @generated from protobuf file "SysMessage.proto" (package "SysMessage", syntax proto3)
|
|
// tslint:disable
|
|
import type {
|
|
BinaryReadOptions,
|
|
BinaryWriteOptions,
|
|
IBinaryReader,
|
|
IBinaryWriter,
|
|
PartialMessage,
|
|
} from '@protobuf-ts/runtime';
|
|
import { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } from '@protobuf-ts/runtime';
|
|
|
|
/**
|
|
* @generated from protobuf message SysMessage.SysMessage
|
|
*/
|
|
export interface SysMessage {
|
|
/**
|
|
* @generated from protobuf field: repeated SysMessage.SysMessageHeader header = 1;
|
|
*/
|
|
header: SysMessageHeader[];
|
|
/**
|
|
* @generated from protobuf field: repeated SysMessage.SysMessageMsgSpec msgSpec = 2;
|
|
*/
|
|
msgSpec: SysMessageMsgSpec[];
|
|
/**
|
|
* @generated from protobuf field: SysMessage.SysMessageBodyWrapper bodyWrapper = 3;
|
|
*/
|
|
bodyWrapper?: SysMessageBodyWrapper;
|
|
}
|
|
/**
|
|
* @generated from protobuf message SysMessage.SysMessageHeader
|
|
*/
|
|
export interface SysMessageHeader {
|
|
/**
|
|
* @generated from protobuf field: uint32 PeerNumber = 1 [json_name = "PeerNumber"];
|
|
*/
|
|
peerNumber: number;
|
|
/**
|
|
* @generated from protobuf field: string PeerString = 2 [json_name = "PeerString"];
|
|
*/
|
|
peerString: string;
|
|
/**
|
|
* @generated from protobuf field: uint32 Uin = 5 [json_name = "Uin"];
|
|
*/
|
|
uin: number;
|
|
/**
|
|
* @generated from protobuf field: optional string Uid = 6 [json_name = "Uid"];
|
|
*/
|
|
uid?: string;
|
|
}
|
|
/**
|
|
* @generated from protobuf message SysMessage.SysMessageMsgSpec
|
|
*/
|
|
export interface SysMessageMsgSpec {
|
|
/**
|
|
* @generated from protobuf field: uint32 msgType = 1;
|
|
*/
|
|
msgType: number;
|
|
/**
|
|
* @generated from protobuf field: uint32 subType = 2;
|
|
*/
|
|
subType: number;
|
|
/**
|
|
* @generated from protobuf field: uint32 subSubType = 3;
|
|
*/
|
|
subSubType: number;
|
|
/**
|
|
* @generated from protobuf field: uint32 msgSeq = 5;
|
|
*/
|
|
msgSeq: number;
|
|
/**
|
|
* @generated from protobuf field: uint32 time = 6;
|
|
*/
|
|
time: number;
|
|
/**
|
|
* @generated from protobuf field: uint64 msgId = 12;
|
|
*/
|
|
msgId: bigint;
|
|
/**
|
|
* @generated from protobuf field: uint32 other = 13;
|
|
*/
|
|
other: number;
|
|
}
|
|
/**
|
|
* @generated from protobuf message SysMessage.SysMessageBodyWrapper
|
|
*/
|
|
export interface SysMessageBodyWrapper {
|
|
/**
|
|
* @generated from protobuf field: bytes wrappedBody = 2;
|
|
*/
|
|
wrappedBody: Uint8Array; // Find the first [08], or ignore the first 7 bytes?
|
|
// And it becomes another ProtoBuf message.
|
|
}
|
|
/**
|
|
* @generated from protobuf message SysMessage.KeyValuePair
|
|
*/
|
|
export interface KeyValuePair {
|
|
/**
|
|
* @generated from protobuf field: string key = 1;
|
|
*/
|
|
key: string;
|
|
/**
|
|
* @generated from protobuf field: string value = 2;
|
|
*/
|
|
value: string;
|
|
}
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SysMessage$Type extends MessageType<SysMessage> {
|
|
constructor() {
|
|
super("SysMessage.SysMessage", [
|
|
{ no: 1, name: "header", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => SysMessageHeader },
|
|
{ no: 2, name: "msgSpec", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => SysMessageMsgSpec },
|
|
{ no: 3, name: "bodyWrapper", kind: "message", T: () => SysMessageBodyWrapper }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SysMessage>): SysMessage {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.header = [];
|
|
message.msgSpec = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SysMessage>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SysMessage): SysMessage {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated SysMessage.SysMessageHeader header */ 1:
|
|
message.header.push(SysMessageHeader.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* repeated SysMessage.SysMessageMsgSpec msgSpec */ 2:
|
|
message.msgSpec.push(SysMessageMsgSpec.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* SysMessage.SysMessageBodyWrapper bodyWrapper */ 3:
|
|
message.bodyWrapper = SysMessageBodyWrapper.internalBinaryRead(reader, reader.uint32(), options, message.bodyWrapper);
|
|
break;
|
|
default:
|
|
let u = options.readUnknownField;
|
|
if (u === "throw")
|
|
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
|
let d = reader.skip(wireType);
|
|
if (u !== false)
|
|
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
internalBinaryWrite(message: SysMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* repeated SysMessage.SysMessageHeader header = 1; */
|
|
for (let i = 0; i < message.header.length; i++)
|
|
SysMessageHeader.internalBinaryWrite(message.header[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* repeated SysMessage.SysMessageMsgSpec msgSpec = 2; */
|
|
for (let i = 0; i < message.msgSpec.length; i++)
|
|
SysMessageMsgSpec.internalBinaryWrite(message.msgSpec[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* SysMessage.SysMessageBodyWrapper bodyWrapper = 3; */
|
|
if (message.bodyWrapper)
|
|
SysMessageBodyWrapper.internalBinaryWrite(message.bodyWrapper, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message SysMessage.SysMessage
|
|
*/
|
|
export const SysMessage = new SysMessage$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SysMessageHeader$Type extends MessageType<SysMessageHeader> {
|
|
constructor() {
|
|
super("SysMessage.SysMessageHeader", [
|
|
{ no: 1, name: "PeerNumber", kind: "scalar", jsonName: "PeerNumber", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 2, name: "PeerString", kind: "scalar", jsonName: "PeerString", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 5, name: "Uin", kind: "scalar", jsonName: "Uin", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 6, name: "Uid", kind: "scalar", jsonName: "Uid", opt: true, T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SysMessageHeader>): SysMessageHeader {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.peerNumber = 0;
|
|
message.peerString = "";
|
|
message.uin = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SysMessageHeader>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SysMessageHeader): SysMessageHeader {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* uint32 PeerNumber = 1 [json_name = "PeerNumber"];*/ 1:
|
|
message.peerNumber = reader.uint32();
|
|
break;
|
|
case /* string PeerString = 2 [json_name = "PeerString"];*/ 2:
|
|
message.peerString = reader.string();
|
|
break;
|
|
case /* uint32 Uin = 5 [json_name = "Uin"];*/ 5:
|
|
message.uin = reader.uint32();
|
|
break;
|
|
case /* optional string Uid = 6 [json_name = "Uid"];*/ 6:
|
|
message.uid = reader.string();
|
|
break;
|
|
default:
|
|
let u = options.readUnknownField;
|
|
if (u === "throw")
|
|
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
|
let d = reader.skip(wireType);
|
|
if (u !== false)
|
|
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
internalBinaryWrite(message: SysMessageHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* uint32 PeerNumber = 1 [json_name = "PeerNumber"]; */
|
|
if (message.peerNumber !== 0)
|
|
writer.tag(1, WireType.Varint).uint32(message.peerNumber);
|
|
/* string PeerString = 2 [json_name = "PeerString"]; */
|
|
if (message.peerString !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.peerString);
|
|
/* uint32 Uin = 5 [json_name = "Uin"]; */
|
|
if (message.uin !== 0)
|
|
writer.tag(5, WireType.Varint).uint32(message.uin);
|
|
/* optional string Uid = 6 [json_name = "Uid"]; */
|
|
if (message.uid !== undefined)
|
|
writer.tag(6, WireType.LengthDelimited).string(message.uid);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message SysMessage.SysMessageHeader
|
|
*/
|
|
export const SysMessageHeader = new SysMessageHeader$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SysMessageMsgSpec$Type extends MessageType<SysMessageMsgSpec> {
|
|
constructor() {
|
|
super("SysMessage.SysMessageMsgSpec", [
|
|
{ no: 1, name: "msgType", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 2, name: "subType", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 3, name: "subSubType", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 5, name: "msgSeq", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 6, name: "time", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
|
|
{ no: 12, name: "msgId", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
|
|
{ no: 13, name: "other", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SysMessageMsgSpec>): SysMessageMsgSpec {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.msgType = 0;
|
|
message.subType = 0;
|
|
message.subSubType = 0;
|
|
message.msgSeq = 0;
|
|
message.time = 0;
|
|
message.msgId = 0n;
|
|
message.other = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SysMessageMsgSpec>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SysMessageMsgSpec): SysMessageMsgSpec {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* uint32 msgType */ 1:
|
|
message.msgType = reader.uint32();
|
|
break;
|
|
case /* uint32 subType */ 2:
|
|
message.subType = reader.uint32();
|
|
break;
|
|
case /* uint32 subSubType */ 3:
|
|
message.subSubType = reader.uint32();
|
|
break;
|
|
case /* uint32 msgSeq */ 5:
|
|
message.msgSeq = reader.uint32();
|
|
break;
|
|
case /* uint32 time */ 6:
|
|
message.time = reader.uint32();
|
|
break;
|
|
case /* uint64 msgId */ 12:
|
|
message.msgId = reader.uint64().toBigInt();
|
|
break;
|
|
case /* uint32 other */ 13:
|
|
message.other = reader.uint32();
|
|
break;
|
|
default:
|
|
let u = options.readUnknownField;
|
|
if (u === "throw")
|
|
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
|
let d = reader.skip(wireType);
|
|
if (u !== false)
|
|
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
internalBinaryWrite(message: SysMessageMsgSpec, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* uint32 msgType = 1; */
|
|
if (message.msgType !== 0)
|
|
writer.tag(1, WireType.Varint).uint32(message.msgType);
|
|
/* uint32 subType = 2; */
|
|
if (message.subType !== 0)
|
|
writer.tag(2, WireType.Varint).uint32(message.subType);
|
|
/* uint32 subSubType = 3; */
|
|
if (message.subSubType !== 0)
|
|
writer.tag(3, WireType.Varint).uint32(message.subSubType);
|
|
/* uint32 msgSeq = 5; */
|
|
if (message.msgSeq !== 0)
|
|
writer.tag(5, WireType.Varint).uint32(message.msgSeq);
|
|
/* uint32 time = 6; */
|
|
if (message.time !== 0)
|
|
writer.tag(6, WireType.Varint).uint32(message.time);
|
|
/* uint64 msgId = 12; */
|
|
if (message.msgId !== 0n)
|
|
writer.tag(12, WireType.Varint).uint64(message.msgId);
|
|
/* uint32 other = 13; */
|
|
if (message.other !== 0)
|
|
writer.tag(13, WireType.Varint).uint32(message.other);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message SysMessage.SysMessageMsgSpec
|
|
*/
|
|
export const SysMessageMsgSpec = new SysMessageMsgSpec$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SysMessageBodyWrapper$Type extends MessageType<SysMessageBodyWrapper> {
|
|
constructor() {
|
|
super("SysMessage.SysMessageBodyWrapper", [
|
|
{ no: 2, name: "wrappedBody", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SysMessageBodyWrapper>): SysMessageBodyWrapper {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.wrappedBody = new Uint8Array(0);
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SysMessageBodyWrapper>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SysMessageBodyWrapper): SysMessageBodyWrapper {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* bytes wrappedBody */ 2:
|
|
message.wrappedBody = reader.bytes();
|
|
break;
|
|
default:
|
|
let u = options.readUnknownField;
|
|
if (u === "throw")
|
|
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
|
let d = reader.skip(wireType);
|
|
if (u !== false)
|
|
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
internalBinaryWrite(message: SysMessageBodyWrapper, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* bytes wrappedBody = 2; */
|
|
if (message.wrappedBody.length)
|
|
writer.tag(2, WireType.LengthDelimited).bytes(message.wrappedBody);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message SysMessage.SysMessageBodyWrapper
|
|
*/
|
|
export const SysMessageBodyWrapper = new SysMessageBodyWrapper$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class KeyValuePair$Type extends MessageType<KeyValuePair> {
|
|
constructor() {
|
|
super("SysMessage.KeyValuePair", [
|
|
{ no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<KeyValuePair>): KeyValuePair {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.key = "";
|
|
message.value = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<KeyValuePair>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyValuePair): KeyValuePair {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string key */ 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case /* string value */ 2:
|
|
message.value = reader.string();
|
|
break;
|
|
default:
|
|
let u = options.readUnknownField;
|
|
if (u === "throw")
|
|
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
|
let d = reader.skip(wireType);
|
|
if (u !== false)
|
|
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
internalBinaryWrite(message: KeyValuePair, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string key = 1; */
|
|
if (message.key !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.key);
|
|
/* string value = 2; */
|
|
if (message.value !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.value);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message SysMessage.KeyValuePair
|
|
*/
|
|
export const KeyValuePair = new KeyValuePair$Type();
|