@tf2pickup-org/mumble-protocol
Version:
Mumble protocol typings
1,048 lines • 143 kB
JavaScript
import { WireType } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
/**
* @generated from protobuf enum MumbleProto.Reject.RejectType
*/
export var Reject_RejectType;
(function (Reject_RejectType) {
/**
* The rejection reason is unknown (details should be available
* in Reject.reason).
*
* @generated from protobuf enum value: None = 0;
*/
Reject_RejectType[Reject_RejectType["None"] = 0] = "None";
/**
* The client attempted to connect with an incompatible version.
*
* @generated from protobuf enum value: WrongVersion = 1;
*/
Reject_RejectType[Reject_RejectType["WrongVersion"] = 1] = "WrongVersion";
/**
* The user name supplied by the client was invalid.
*
* @generated from protobuf enum value: InvalidUsername = 2;
*/
Reject_RejectType[Reject_RejectType["InvalidUsername"] = 2] = "InvalidUsername";
/**
* The client attempted to authenticate as a user with a password but it
* was wrong.
*
* @generated from protobuf enum value: WrongUserPW = 3;
*/
Reject_RejectType[Reject_RejectType["WrongUserPW"] = 3] = "WrongUserPW";
/**
* The client attempted to connect to a passworded server but the password
* was wrong.
*
* @generated from protobuf enum value: WrongServerPW = 4;
*/
Reject_RejectType[Reject_RejectType["WrongServerPW"] = 4] = "WrongServerPW";
/**
* Supplied username is already in use.
*
* @generated from protobuf enum value: UsernameInUse = 5;
*/
Reject_RejectType[Reject_RejectType["UsernameInUse"] = 5] = "UsernameInUse";
/**
* Server is currently full and cannot accept more users.
*
* @generated from protobuf enum value: ServerFull = 6;
*/
Reject_RejectType[Reject_RejectType["ServerFull"] = 6] = "ServerFull";
/**
* The user did not provide a certificate but one is required.
*
* @generated from protobuf enum value: NoCertificate = 7;
*/
Reject_RejectType[Reject_RejectType["NoCertificate"] = 7] = "NoCertificate";
/**
* @generated from protobuf enum value: AuthenticatorFail = 8;
*/
Reject_RejectType[Reject_RejectType["AuthenticatorFail"] = 8] = "AuthenticatorFail";
})(Reject_RejectType || (Reject_RejectType = {}));
/**
* @generated from protobuf enum MumbleProto.PermissionDenied.DenyType
*/
export var PermissionDenied_DenyType;
(function (PermissionDenied_DenyType) {
/**
* Operation denied for other reason, see reason field.
*
* @generated from protobuf enum value: Text = 0;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["Text"] = 0] = "Text";
/**
* Permissions were denied.
*
* @generated from protobuf enum value: Permission = 1;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["Permission"] = 1] = "Permission";
/**
* Cannot modify SuperUser.
*
* @generated from protobuf enum value: SuperUser = 2;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["SuperUser"] = 2] = "SuperUser";
/**
* Invalid channel name.
*
* @generated from protobuf enum value: ChannelName = 3;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["ChannelName"] = 3] = "ChannelName";
/**
* Text message too long.
*
* @generated from protobuf enum value: TextTooLong = 4;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["TextTooLong"] = 4] = "TextTooLong";
/**
* The flux capacitor was spelled wrong.
*
* @generated from protobuf enum value: H9K = 5;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["H9K"] = 5] = "H9K";
/**
* Operation not permitted in temporary channel.
*
* @generated from protobuf enum value: TemporaryChannel = 6;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["TemporaryChannel"] = 6] = "TemporaryChannel";
/**
* Operation requires certificate.
*
* @generated from protobuf enum value: MissingCertificate = 7;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["MissingCertificate"] = 7] = "MissingCertificate";
/**
* Invalid username.
*
* @generated from protobuf enum value: UserName = 8;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["UserName"] = 8] = "UserName";
/**
* Channel is full.
*
* @generated from protobuf enum value: ChannelFull = 9;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["ChannelFull"] = 9] = "ChannelFull";
/**
* Channels are nested too deeply.
*
* @generated from protobuf enum value: NestingLimit = 10;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["NestingLimit"] = 10] = "NestingLimit";
/**
* Maximum channel count reached.
*
* @generated from protobuf enum value: ChannelCountLimit = 11;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["ChannelCountLimit"] = 11] = "ChannelCountLimit";
/**
* Amount of listener objects for this channel has been reached
*
* @generated from protobuf enum value: ChannelListenerLimit = 12;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["ChannelListenerLimit"] = 12] = "ChannelListenerLimit";
/**
* Amount of listener proxies for the user has been reached
*
* @generated from protobuf enum value: UserListenerLimit = 13;
*/
PermissionDenied_DenyType[PermissionDenied_DenyType["UserListenerLimit"] = 13] = "UserListenerLimit";
})(PermissionDenied_DenyType || (PermissionDenied_DenyType = {}));
/**
* @generated from protobuf enum MumbleProto.ContextActionModify.Context
*/
export var ContextActionModify_Context;
(function (ContextActionModify_Context) {
/**
* @generated synthetic value - protobuf-ts requires all enums to have a 0 value
*/
ContextActionModify_Context[ContextActionModify_Context["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
/**
* Action is applicable to the server.
*
* @generated from protobuf enum value: Server = 1;
*/
ContextActionModify_Context[ContextActionModify_Context["Server"] = 1] = "Server";
/**
* Action can target a Channel.
*
* @generated from protobuf enum value: Channel = 2;
*/
ContextActionModify_Context[ContextActionModify_Context["Channel"] = 2] = "Channel";
/**
* Action can target a User.
*
* @generated from protobuf enum value: User = 4;
*/
ContextActionModify_Context[ContextActionModify_Context["User"] = 4] = "User";
})(ContextActionModify_Context || (ContextActionModify_Context = {}));
/**
* @generated from protobuf enum MumbleProto.ContextActionModify.Operation
*/
export var ContextActionModify_Operation;
(function (ContextActionModify_Operation) {
/**
* @generated from protobuf enum value: Add = 0;
*/
ContextActionModify_Operation[ContextActionModify_Operation["Add"] = 0] = "Add";
/**
* @generated from protobuf enum value: Remove = 1;
*/
ContextActionModify_Operation[ContextActionModify_Operation["Remove"] = 1] = "Remove";
})(ContextActionModify_Operation || (ContextActionModify_Operation = {}));
// @generated message type with reflection information, may provide speed optimized methods
class Version$Type extends MessageType {
constructor() {
super("MumbleProto.Version", [
{ no: 1, name: "version_v1", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "version_v2", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
{ no: 2, name: "release", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 3, name: "os", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "os_version", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional uint32 version_v1 */ 1:
message.versionV1 = reader.uint32();
break;
case /* optional uint64 version_v2 */ 5:
message.versionV2 = reader.uint64().toBigInt();
break;
case /* optional string release */ 2:
message.release = reader.string();
break;
case /* optional string os */ 3:
message.os = reader.string();
break;
case /* optional string os_version */ 4:
message.osVersion = 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, writer, options) {
/* optional uint32 version_v1 = 1; */
if (message.versionV1 !== undefined)
writer.tag(1, WireType.Varint).uint32(message.versionV1);
/* optional string release = 2; */
if (message.release !== undefined)
writer.tag(2, WireType.LengthDelimited).string(message.release);
/* optional string os = 3; */
if (message.os !== undefined)
writer.tag(3, WireType.LengthDelimited).string(message.os);
/* optional string os_version = 4; */
if (message.osVersion !== undefined)
writer.tag(4, WireType.LengthDelimited).string(message.osVersion);
/* optional uint64 version_v2 = 5; */
if (message.versionV2 !== undefined)
writer.tag(5, WireType.Varint).uint64(message.versionV2);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.Version
*/
export const Version = new Version$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UDPTunnel$Type extends MessageType {
constructor() {
super("MumbleProto.UDPTunnel", [
{ no: 1, name: "packet", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.packet = new Uint8Array(0);
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* required bytes packet */ 1:
message.packet = 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, writer, options) {
/* required bytes packet = 1; */
if (message.packet.length)
writer.tag(1, WireType.LengthDelimited).bytes(message.packet);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.UDPTunnel
*/
export const UDPTunnel = new UDPTunnel$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Authenticate$Type extends MessageType {
constructor() {
super("MumbleProto.Authenticate", [
{ no: 1, name: "username", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 2, name: "password", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 3, name: "tokens", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "celt_versions", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ },
{ no: 5, name: "opus", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 6, name: "client_type", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.tokens = [];
message.celtVersions = [];
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional string username */ 1:
message.username = reader.string();
break;
case /* optional string password */ 2:
message.password = reader.string();
break;
case /* repeated string tokens */ 3:
message.tokens.push(reader.string());
break;
case /* repeated int32 celt_versions */ 4:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.celtVersions.push(reader.int32());
else
message.celtVersions.push(reader.int32());
break;
case /* optional bool opus = 5 [default = false] */ 5:
message.opus = reader.bool();
break;
case /* optional int32 client_type = 6 [default = 0] */ 6:
message.clientType = reader.int32();
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, writer, options) {
/* optional string username = 1; */
if (message.username !== undefined)
writer.tag(1, WireType.LengthDelimited).string(message.username);
/* optional string password = 2; */
if (message.password !== undefined)
writer.tag(2, WireType.LengthDelimited).string(message.password);
/* repeated string tokens = 3; */
for (let i = 0; i < message.tokens.length; i++)
writer.tag(3, WireType.LengthDelimited).string(message.tokens[i]);
/* repeated int32 celt_versions = 4; */
for (let i = 0; i < message.celtVersions.length; i++)
writer.tag(4, WireType.Varint).int32(message.celtVersions[i]);
/* optional bool opus = 5 [default = false]; */
if (message.opus !== undefined)
writer.tag(5, WireType.Varint).bool(message.opus);
/* optional int32 client_type = 6 [default = 0]; */
if (message.clientType !== undefined)
writer.tag(6, WireType.Varint).int32(message.clientType);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.Authenticate
*/
export const Authenticate = new Authenticate$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Ping$Type extends MessageType {
constructor() {
super("MumbleProto.Ping", [
{ no: 1, name: "timestamp", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
{ no: 2, name: "good", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "late", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 4, name: "lost", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "resync", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 6, name: "udp_packets", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 7, name: "tcp_packets", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 8, name: "udp_ping_avg", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
{ no: 9, name: "udp_ping_var", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
{ no: 10, name: "tcp_ping_avg", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
{ no: 11, name: "tcp_ping_var", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional uint64 timestamp */ 1:
message.timestamp = reader.uint64().toBigInt();
break;
case /* optional uint32 good */ 2:
message.good = reader.uint32();
break;
case /* optional uint32 late */ 3:
message.late = reader.uint32();
break;
case /* optional uint32 lost */ 4:
message.lost = reader.uint32();
break;
case /* optional uint32 resync */ 5:
message.resync = reader.uint32();
break;
case /* optional uint32 udp_packets */ 6:
message.udpPackets = reader.uint32();
break;
case /* optional uint32 tcp_packets */ 7:
message.tcpPackets = reader.uint32();
break;
case /* optional float udp_ping_avg */ 8:
message.udpPingAvg = reader.float();
break;
case /* optional float udp_ping_var */ 9:
message.udpPingVar = reader.float();
break;
case /* optional float tcp_ping_avg */ 10:
message.tcpPingAvg = reader.float();
break;
case /* optional float tcp_ping_var */ 11:
message.tcpPingVar = reader.float();
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, writer, options) {
/* optional uint64 timestamp = 1; */
if (message.timestamp !== undefined)
writer.tag(1, WireType.Varint).uint64(message.timestamp);
/* optional uint32 good = 2; */
if (message.good !== undefined)
writer.tag(2, WireType.Varint).uint32(message.good);
/* optional uint32 late = 3; */
if (message.late !== undefined)
writer.tag(3, WireType.Varint).uint32(message.late);
/* optional uint32 lost = 4; */
if (message.lost !== undefined)
writer.tag(4, WireType.Varint).uint32(message.lost);
/* optional uint32 resync = 5; */
if (message.resync !== undefined)
writer.tag(5, WireType.Varint).uint32(message.resync);
/* optional uint32 udp_packets = 6; */
if (message.udpPackets !== undefined)
writer.tag(6, WireType.Varint).uint32(message.udpPackets);
/* optional uint32 tcp_packets = 7; */
if (message.tcpPackets !== undefined)
writer.tag(7, WireType.Varint).uint32(message.tcpPackets);
/* optional float udp_ping_avg = 8; */
if (message.udpPingAvg !== undefined)
writer.tag(8, WireType.Bit32).float(message.udpPingAvg);
/* optional float udp_ping_var = 9; */
if (message.udpPingVar !== undefined)
writer.tag(9, WireType.Bit32).float(message.udpPingVar);
/* optional float tcp_ping_avg = 10; */
if (message.tcpPingAvg !== undefined)
writer.tag(10, WireType.Bit32).float(message.tcpPingAvg);
/* optional float tcp_ping_var = 11; */
if (message.tcpPingVar !== undefined)
writer.tag(11, WireType.Bit32).float(message.tcpPingVar);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.Ping
*/
export const Ping = new Ping$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Reject$Type extends MessageType {
constructor() {
super("MumbleProto.Reject", [
{ no: 1, name: "type", kind: "enum", opt: true, T: () => ["MumbleProto.Reject.RejectType", Reject_RejectType] },
{ no: 2, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional MumbleProto.Reject.RejectType type */ 1:
message.type = reader.int32();
break;
case /* optional string reason */ 2:
message.reason = 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, writer, options) {
/* optional MumbleProto.Reject.RejectType type = 1; */
if (message.type !== undefined)
writer.tag(1, WireType.Varint).int32(message.type);
/* optional string reason = 2; */
if (message.reason !== undefined)
writer.tag(2, WireType.LengthDelimited).string(message.reason);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.Reject
*/
export const Reject = new Reject$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ServerSync$Type extends MessageType {
constructor() {
super("MumbleProto.ServerSync", [
{ no: 1, name: "session", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "max_bandwidth", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "welcome_text", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "permissions", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional uint32 session */ 1:
message.session = reader.uint32();
break;
case /* optional uint32 max_bandwidth */ 2:
message.maxBandwidth = reader.uint32();
break;
case /* optional string welcome_text */ 3:
message.welcomeText = reader.string();
break;
case /* optional uint64 permissions */ 4:
message.permissions = reader.uint64().toBigInt();
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, writer, options) {
/* optional uint32 session = 1; */
if (message.session !== undefined)
writer.tag(1, WireType.Varint).uint32(message.session);
/* optional uint32 max_bandwidth = 2; */
if (message.maxBandwidth !== undefined)
writer.tag(2, WireType.Varint).uint32(message.maxBandwidth);
/* optional string welcome_text = 3; */
if (message.welcomeText !== undefined)
writer.tag(3, WireType.LengthDelimited).string(message.welcomeText);
/* optional uint64 permissions = 4; */
if (message.permissions !== undefined)
writer.tag(4, WireType.Varint).uint64(message.permissions);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.ServerSync
*/
export const ServerSync = new ServerSync$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ChannelRemove$Type extends MessageType {
constructor() {
super("MumbleProto.ChannelRemove", [
{ no: 1, name: "channel_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.channelId = 0;
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* required uint32 channel_id */ 1:
message.channelId = 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, writer, options) {
/* required uint32 channel_id = 1; */
if (message.channelId !== 0)
writer.tag(1, WireType.Varint).uint32(message.channelId);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.ChannelRemove
*/
export const ChannelRemove = new ChannelRemove$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ChannelState$Type extends MessageType {
constructor() {
super("MumbleProto.ChannelState", [
{ no: 1, name: "channel_id", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "parent", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "links", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "description", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 6, name: "links_add", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
{ no: 7, name: "links_remove", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
{ no: 8, name: "temporary", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 9, name: "position", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
{ no: 10, name: "description_hash", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
{ no: 11, name: "max_users", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 12, name: "is_enter_restricted", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 13, name: "can_enter", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.links = [];
message.linksAdd = [];
message.linksRemove = [];
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional uint32 channel_id */ 1:
message.channelId = reader.uint32();
break;
case /* optional uint32 parent */ 2:
message.parent = reader.uint32();
break;
case /* optional string name */ 3:
message.name = reader.string();
break;
case /* repeated uint32 links */ 4:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.links.push(reader.uint32());
else
message.links.push(reader.uint32());
break;
case /* optional string description */ 5:
message.description = reader.string();
break;
case /* repeated uint32 links_add */ 6:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.linksAdd.push(reader.uint32());
else
message.linksAdd.push(reader.uint32());
break;
case /* repeated uint32 links_remove */ 7:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.linksRemove.push(reader.uint32());
else
message.linksRemove.push(reader.uint32());
break;
case /* optional bool temporary = 8 [default = false] */ 8:
message.temporary = reader.bool();
break;
case /* optional int32 position = 9 [default = 0] */ 9:
message.position = reader.int32();
break;
case /* optional bytes description_hash */ 10:
message.descriptionHash = reader.bytes();
break;
case /* optional uint32 max_users */ 11:
message.maxUsers = reader.uint32();
break;
case /* optional bool is_enter_restricted */ 12:
message.isEnterRestricted = reader.bool();
break;
case /* optional bool can_enter */ 13:
message.canEnter = reader.bool();
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, writer, options) {
/* optional uint32 channel_id = 1; */
if (message.channelId !== undefined)
writer.tag(1, WireType.Varint).uint32(message.channelId);
/* optional uint32 parent = 2; */
if (message.parent !== undefined)
writer.tag(2, WireType.Varint).uint32(message.parent);
/* optional string name = 3; */
if (message.name !== undefined)
writer.tag(3, WireType.LengthDelimited).string(message.name);
/* repeated uint32 links = 4; */
for (let i = 0; i < message.links.length; i++)
writer.tag(4, WireType.Varint).uint32(message.links[i]);
/* optional string description = 5; */
if (message.description !== undefined)
writer.tag(5, WireType.LengthDelimited).string(message.description);
/* repeated uint32 links_add = 6; */
for (let i = 0; i < message.linksAdd.length; i++)
writer.tag(6, WireType.Varint).uint32(message.linksAdd[i]);
/* repeated uint32 links_remove = 7; */
for (let i = 0; i < message.linksRemove.length; i++)
writer.tag(7, WireType.Varint).uint32(message.linksRemove[i]);
/* optional bool temporary = 8 [default = false]; */
if (message.temporary !== undefined)
writer.tag(8, WireType.Varint).bool(message.temporary);
/* optional int32 position = 9 [default = 0]; */
if (message.position !== undefined)
writer.tag(9, WireType.Varint).int32(message.position);
/* optional bytes description_hash = 10; */
if (message.descriptionHash !== undefined)
writer.tag(10, WireType.LengthDelimited).bytes(message.descriptionHash);
/* optional uint32 max_users = 11; */
if (message.maxUsers !== undefined)
writer.tag(11, WireType.Varint).uint32(message.maxUsers);
/* optional bool is_enter_restricted = 12; */
if (message.isEnterRestricted !== undefined)
writer.tag(12, WireType.Varint).bool(message.isEnterRestricted);
/* optional bool can_enter = 13; */
if (message.canEnter !== undefined)
writer.tag(13, WireType.Varint).bool(message.canEnter);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.ChannelState
*/
export const ChannelState = new ChannelState$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UserRemove$Type extends MessageType {
constructor() {
super("MumbleProto.UserRemove", [
{ no: 1, name: "session", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "actor", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "ban", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.session = 0;
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* required uint32 session */ 1:
message.session = reader.uint32();
break;
case /* optional uint32 actor */ 2:
message.actor = reader.uint32();
break;
case /* optional string reason */ 3:
message.reason = reader.string();
break;
case /* optional bool ban */ 4:
message.ban = reader.bool();
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, writer, options) {
/* required uint32 session = 1; */
if (message.session !== 0)
writer.tag(1, WireType.Varint).uint32(message.session);
/* optional uint32 actor = 2; */
if (message.actor !== undefined)
writer.tag(2, WireType.Varint).uint32(message.actor);
/* optional string reason = 3; */
if (message.reason !== undefined)
writer.tag(3, WireType.LengthDelimited).string(message.reason);
/* optional bool ban = 4; */
if (message.ban !== undefined)
writer.tag(4, WireType.Varint).bool(message.ban);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message MumbleProto.UserRemove
*/
export const UserRemove = new UserRemove$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UserState$Type extends MessageType {
constructor() {
super("MumbleProto.UserState", [
{ no: 1, name: "session", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "actor", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "user_id", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "channel_id", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
{ no: 6, name: "mute", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 7, name: "deaf", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 8, name: "suppress", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 9, name: "self_mute", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 10, name: "self_deaf", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 11, name: "texture", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
{ no: 12, name: "plugin_context", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
{ no: 13, name: "plugin_identity", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 14, name: "comment", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 15, name: "hash", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
{ no: 16, name: "comment_hash", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
{ no: 17, name: "texture_hash", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
{ no: 18, name: "priority_speaker", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 19, name: "recording", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
{ no: 20, name: "temporary_access_tokens", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
{ no: 21, name: "listening_channel_add", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
{ no: 22, name: "listening_channel_remove", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
{ no: 23, name: "listening_volume_adjustment", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UserState_VolumeAdjustment }
]);
}
create(value) {
const message = globalThis.Object.create((this.messagePrototype));
message.temporaryAccessTokens = [];
message.listeningChannelAdd = [];
message.listeningChannelRemove = [];
message.listeningVolumeAdjustment = [];
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* optional uint32 session */ 1:
message.session = reader.uint32();
break;
case /* optional uint32 actor */ 2:
message.actor = reader.uint32();
break;
case /* optional string name */ 3:
message.name = reader.string();
break;
case /* optional uint32 user_id */ 4:
message.userId = reader.uint32();
break;
case /* optional uint32 channel_id */ 5:
message.channelId = reader.uint32();
break;
case /* optional bool mute */ 6:
message.mute = reader.bool();
break;
case /* optional bool deaf */ 7:
message.deaf = reader.bool();
break;
case /* optional bool suppress */ 8:
message.suppress = reader.bool();
break;
case /* optional bool self_mute */ 9:
message.selfMute = reader.bool();
break;
case /* optional bool self_deaf */ 10:
message.selfDeaf = reader.bool();
break;
case /* optional bytes texture */ 11:
message.texture = reader.bytes();
break;
case /* optional bytes plugin_context */ 12:
message.pluginContext = reader.bytes();
break;
case /* optional string plugin_identity */ 13:
message.pluginIdentity = reader.string();
break;
case /* optional string comment */ 14:
message.comment = reader.string();
break;
case /* optional string hash */ 15:
message.hash = reader.string();
break;
case /* optional bytes comment_hash */ 16:
message.commentHash = reader.bytes();
break;
case /* optional bytes texture_hash */ 17:
message.textureHash = reader.bytes();
break;
case /* optional bool priority_speaker */ 18:
message.prioritySpeaker = reader.bool();
break;
case /* optional bool recording */ 19:
message.recording = reader.bool();
break;
case /* repeated string temporary_access_tokens */ 20:
message.temporaryAccessTokens.push(reader.string());
break;
case /* repeated uint32 listening_channel_add */ 21:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.listeningChannelAdd.push(reader.uint32());
else
message.listeningChannelAdd.push(reader.uint32());
break;
case /* repeated uint32 listening_channel_remove */ 22:
if (wireType === WireType.LengthDelimited)
for (let e = reader.int32() + reader.pos; reader.pos < e;)
message.listeningChannelRemove.push(reader.uint32());
else
message.listeningChannelRemove.push(reader.uint32());
break;
case /* repeated MumbleProto.UserState.VolumeAdjustment listening_volume_adjustment */ 23:
message.listeningVolumeAdjustment.push(UserState_VolumeAdjustment.internalBinaryRead(reader, reader.uint32(), options));
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, writer, options) {
/* optional uint32 session = 1; */
if (message.session !== undefined)
writer.tag(1, WireType.Varint).uint32(message.session);
/* optional uint32 actor = 2; */
if (message.actor !== undefined)
writer.tag(2, WireType.Varint).uint32(message.actor);
/* optional string name = 3; */
if (message.name !== undefined)
writer.tag(3, WireType.LengthDelimited).string(message.name);
/* optional uint32 user_id = 4; */
if (message.userId !== undefined)
writer.tag(4, WireType.Varint).uint32(message.userId);
/* optional uint32 channel_id = 5; */
if (message.channelId !== undefin