@tf2pickup-org/mumble-protocol/dist/Mumble.d.ts

Mumble protocol typings

import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
/**
 * @generated from protobuf message MumbleProto.Version
 */
export interface Version {
    /**
     * Legacy version number format.
     *
     * @generated from protobuf field: optional uint32 version_v1 = 1
     */
    versionV1?: number;
    /**
     * New version number format.
     * Necessary since patch level may exceed 255. (See https://github.com/mumble-voip/mumble/issues/5827)
     *
     * @generated from protobuf field: optional uint64 version_v2 = 5
     */
    versionV2?: bigint;
    /**
     * Client release name.
     *
     * @generated from protobuf field: optional string release = 2
     */
    release?: string;
    /**
     * Client OS name.
     *
     * @generated from protobuf field: optional string os = 3
     */
    os?: string;
    /**
     * Client OS version.
     *
     * @generated from protobuf field: optional string os_version = 4
     */
    osVersion?: string;
}
/**
 * Not used. Not even for tunneling UDP through TCP.
 *
 * @generated from protobuf message MumbleProto.UDPTunnel
 */
export interface UDPTunnel {
    /**
     * Not used.
     *
     * @generated from protobuf field: required bytes packet = 1
     */
    packet: Uint8Array;
}
/**
 * Used by the client to send the authentication credentials to the server.
 *
 * @generated from protobuf message MumbleProto.Authenticate
 */
export interface Authenticate {
    /**
     * UTF-8 encoded username.
     *
     * @generated from protobuf field: optional string username = 1
     */
    username?: string;
    /**
     * Server or user password.
     *
     * @generated from protobuf field: optional string password = 2
     */
    password?: string;
    /**
     * Additional access tokens for server ACL groups.
     *
     * @generated from protobuf field: repeated string tokens = 3
     */
    tokens: string[];
    /**
     * A list of CELT bitstream version constants supported by the client.
     *
     * @generated from protobuf field: repeated int32 celt_versions = 4
     */
    celtVersions: number[];
    /**
     * @generated from protobuf field: optional bool opus = 5 [default = false]
     */
    opus?: boolean;
    /**
     * 0 = REGULAR, 1 = BOT
     *
     * @generated from protobuf field: optional int32 client_type = 6 [default = 0]
     */
    clientType?: number;
}
/**
 * Sent by the client to notify the server that the client is still alive.
 * Server must reply to the packet with the same timestamp and its own
 * good/late/lost/resync numbers. None of the fields is strictly required.
 *
 * @generated from protobuf message MumbleProto.Ping
 */
export interface Ping {
    /**
     * Client timestamp. Server should not attempt to decode.
     *
     * @generated from protobuf field: optional uint64 timestamp = 1
     */
    timestamp?: bigint;
    /**
     * The amount of good packets received.
     *
     * @generated from protobuf field: optional uint32 good = 2
     */
    good?: number;
    /**
     * The amount of late packets received.
     *
     * @generated from protobuf field: optional uint32 late = 3
     */
    late?: number;
    /**
     * The amount of packets never received.
     *
     * @generated from protobuf field: optional uint32 lost = 4
     */
    lost?: number;
    /**
     * The amount of nonce resyncs.
     *
     * @generated from protobuf field: optional uint32 resync = 5
     */
    resync?: number;
    /**
     * The total amount of UDP packets received.
     *
     * @generated from protobuf field: optional uint32 udp_packets = 6
     */
    udpPackets?: number;
    /**
     * The total amount of TCP packets received.
     *
     * @generated from protobuf field: optional uint32 tcp_packets = 7
     */
    tcpPackets?: number;
    /**
     * UDP ping average.
     *
     * @generated from protobuf field: optional float udp_ping_avg = 8
     */
    udpPingAvg?: number;
    /**
     * UDP ping variance.
     *
     * @generated from protobuf field: optional float udp_ping_var = 9
     */
    udpPingVar?: number;
    /**
     * TCP ping average.
     *
     * @generated from protobuf field: optional float tcp_ping_avg = 10
     */
    tcpPingAvg?: number;
    /**
     * TCP ping variance.
     *
     * @generated from protobuf field: optional float tcp_ping_var = 11
     */
    tcpPingVar?: number;
}
/**
 * Sent by the server when it rejects the user connection.
 *
 * @generated from protobuf message MumbleProto.Reject
 */
export interface Reject {
    /**
     * Rejection type.
     *
     * @generated from protobuf field: optional MumbleProto.Reject.RejectType type = 1
     */
    type?: Reject_RejectType;
    /**
     * Human readable rejection reason.
     *
     * @generated from protobuf field: optional string reason = 2
     */
    reason?: string;
}
/**
 * @generated from protobuf enum MumbleProto.Reject.RejectType
 */
export declare enum Reject_RejectType {
    /**
     * The rejection reason is unknown (details should be available
     * in Reject.reason).
     *
     * @generated from protobuf enum value: None = 0;
     */
    None = 0,
    /**
     * The client attempted to connect with an incompatible version.
     *
     * @generated from protobuf enum value: WrongVersion = 1;
     */
    WrongVersion = 1,
    /**
     * The user name supplied by the client was invalid.
     *
     * @generated from protobuf enum value: InvalidUsername = 2;
     */
    InvalidUsername = 2,
    /**
     * The client attempted to authenticate as a user with a password but it
     * was wrong.
     *
     * @generated from protobuf enum value: WrongUserPW = 3;
     */
    WrongUserPW = 3,
    /**
     * The client attempted to connect to a passworded server but the password
     * was wrong.
     *
     * @generated from protobuf enum value: WrongServerPW = 4;
     */
    WrongServerPW = 4,
    /**
     * Supplied username is already in use.
     *
     * @generated from protobuf enum value: UsernameInUse = 5;
     */
    UsernameInUse = 5,
    /**
     * Server is currently full and cannot accept more users.
     *
     * @generated from protobuf enum value: ServerFull = 6;
     */
    ServerFull = 6,
    /**
     * The user did not provide a certificate but one is required.
     *
     * @generated from protobuf enum value: NoCertificate = 7;
     */
    NoCertificate = 7,
    /**
     * @generated from protobuf enum value: AuthenticatorFail = 8;
     */
    AuthenticatorFail = 8
}
/**
 * ServerSync message is sent by the server when it has authenticated the user
 * and finished synchronizing the server state.
 *
 * @generated from protobuf message MumbleProto.ServerSync
 */
export interface ServerSync {
    /**
     * The session of the current user.
     *
     * @generated from protobuf field: optional uint32 session = 1
     */
    session?: number;
    /**
     * Maximum bandwidth that the user should use.
     *
     * @generated from protobuf field: optional uint32 max_bandwidth = 2
     */
    maxBandwidth?: number;
    /**
     * Server welcome text.
     *
     * @generated from protobuf field: optional string welcome_text = 3
     */
    welcomeText?: string;
    /**
     * Current user permissions in the root channel.
     * Note: The permissions data type usually is uin32 (e.g. in PermissionQuery and PermissionDenied messages). Here
     * it is uint64 because of an oversight in the past. Nonetheless it should never exceed the uin32 range.
     * See also: https://github.com/mumble-voip/mumble/issues/5139
     *
     * @generated from protobuf field: optional uint64 permissions = 4
     */
    permissions?: bigint;
}
/**
 * Sent by the client when it wants a channel removed. Sent by the server when
 * a channel has been removed and clients should be notified.
 *
 * @generated from protobuf message MumbleProto.ChannelRemove
 */
export interface ChannelRemove {
    /**
     * @generated from protobuf field: required uint32 channel_id = 1
     */
    channelId: number;
}
/**
 * Used to communicate channel properties between the client and the server.
 * Sent by the server during the login process or when channel properties are
 * updated. Client may use this message to update said channel properties.
 *
 * @generated from protobuf message MumbleProto.ChannelState
 */
export interface ChannelState {
    /**
     * Unique ID for the channel within the server.
     *
     * @generated from protobuf field: optional uint32 channel_id = 1
     */
    channelId?: number;
    /**
     * channel_id of the parent channel.
     *
     * @generated from protobuf field: optional uint32 parent = 2
     */
    parent?: number;
    /**
     * UTF-8 encoded channel name.
     *
     * @generated from protobuf field: optional string name = 3
     */
    name?: string;
    /**
     * A collection of channel id values of the linked channels. Absent during
     * the first channel listing.
     *
     * @generated from protobuf field: repeated uint32 links = 4
     */
    links: number[];
    /**
     * UTF-8 encoded channel description. Only if the description is less than
     * 128 bytes
     *
     * @generated from protobuf field: optional string description = 5
     */
    description?: string;
    /**
     * A collection of channel_id values that should be added to links.
     *
     * @generated from protobuf field: repeated uint32 links_add = 6
     */
    linksAdd: number[];
    /**
     * A collection of channel_id values that should be removed from links.
     *
     * @generated from protobuf field: repeated uint32 links_remove = 7
     */
    linksRemove: number[];
    /**
     * True if the channel is temporary.
     *
     * @generated from protobuf field: optional bool temporary = 8 [default = false]
     */
    temporary?: boolean;
    /**
     * Position weight to tweak the channel position in the channel list.
     *
     * @generated from protobuf field: optional int32 position = 9 [default = 0]
     */
    position?: number;
    /**
     * SHA1 hash of the description if the description is 128 bytes or more.
     *
     * @generated from protobuf field: optional bytes description_hash = 10
     */
    descriptionHash?: Uint8Array;
    /**
     * Maximum number of users allowed in the channel. If this value is zero,
     * the maximum number of users allowed in the channel is given by the
     * server's "usersperchannel" setting.
     *
     * @generated from protobuf field: optional uint32 max_users = 11
     */
    maxUsers?: number;
    /**
     * Whether this channel has enter restrictions (ACL denying ENTER) set
     *
     * @generated from protobuf field: optional bool is_enter_restricted = 12
     */
    isEnterRestricted?: boolean;
    /**
     * Whether the receiver of this msg is considered to be able to enter this channel
     *
     * @generated from protobuf field: optional bool can_enter = 13
     */
    canEnter?: boolean;
}
/**
 * Used to communicate user leaving or being kicked. May be sent by the client
 * when it attempts to kick a user. Sent by the server when it informs the
 * clients that a user is not present anymore.
 *
 * @generated from protobuf message MumbleProto.UserRemove
 */
export interface UserRemove {
    /**
     * The user who is being kicked, identified by their session, not present
     * when no one is being kicked.
     *
     * @generated from protobuf field: required uint32 session = 1
     */
    session: number;
    /**
     * The user who initiated the removal. Either the user who performs the kick
     * or the user who is currently leaving.
     *
     * @generated from protobuf field: optional uint32 actor = 2
     */
    actor?: number;
    /**
     * Reason for the kick, stored as the ban reason if the user is banned.
     *
     * @generated from protobuf field: optional string reason = 3
     */
    reason?: string;
    /**
     * True if the kick should result in a ban.
     *
     * @generated from protobuf field: optional bool ban = 4
     */
    ban?: boolean;
}
/**
 * Sent by the server when it communicates new and changed users to client.
 * First seen during login procedure. May be sent by the client when it wishes
 * to alter its state.
 *
 * @generated from protobuf message MumbleProto.UserState
 */
export interface UserState {
    /**
     * Unique user session ID of the user whose state this is, may change on
     * reconnect.
     *
     * @generated from protobuf field: optional uint32 session = 1
     */
    session?: number;
    /**
     * The session of the user who is updating this user.
     *
     * @generated from protobuf field: optional uint32 actor = 2
     */
    actor?: number;
    /**
     * User name, UTF-8 encoded.
     *
     * @generated from protobuf field: optional string name = 3
     */
    name?: string;
    /**
     * Registered user ID if the user is registered.
     *
     * @generated from protobuf field: optional uint32 user_id = 4
     */
    userId?: number;
    /**
     * Channel on which the user is.
     *
     * @generated from protobuf field: optional uint32 channel_id = 5
     */
    channelId?: number;
    /**
     * True if the user is muted by admin.
     *
     * @generated from protobuf field: optional bool mute = 6
     */
    mute?: boolean;
    /**
     * True if the user is deafened by admin.
     *
     * @generated from protobuf field: optional bool deaf = 7
     */
    deaf?: boolean;
    /**
     * True if the user has been suppressed from talking by a reason other than
     * being muted.
     *
     * @generated from protobuf field: optional bool suppress = 8
     */
    suppress?: boolean;
    /**
     * True if the user has muted self.
     *
     * @generated from protobuf field: optional bool self_mute = 9
     */
    selfMute?: boolean;
    /**
     * True if the user has deafened self.
     *
     * @generated from protobuf field: optional bool self_deaf = 10
     */
    selfDeaf?: boolean;
    /**
     * User image if it is less than 128 bytes.
     *
     * @generated from protobuf field: optional bytes texture = 11
     */
    texture?: Uint8Array;
    /**
     * The positional audio plugin identifier.
     * Positional audio information is only sent to users who share
     * identical plugin contexts.
     *
     * This value is not transmitted to clients.
     *
     * @generated from protobuf field: optional bytes plugin_context = 12
     */
    pluginContext?: Uint8Array;
    /**
     * The user's plugin-specific identity.
     * This value is not transmitted to clients.
     *
     * @generated from protobuf field: optional string plugin_identity = 13
     */
    pluginIdentity?: string;
    /**
     * User comment if it is less than 128 bytes.
     *
     * @generated from protobuf field: optional string comment = 14
     */
    comment?: string;
    /**
     * The hash of the user certificate.
     *
     * @generated from protobuf field: optional string hash = 15
     */
    hash?: string;
    /**
     * SHA1 hash of the user comment if it 128 bytes or more.
     *
     * @generated from protobuf field: optional bytes comment_hash = 16
     */
    commentHash?: Uint8Array;
    /**
     * SHA1 hash of the user picture if it 128 bytes or more.
     *
     * @generated from protobuf field: optional bytes texture_hash = 17
     */
    textureHash?: Uint8Array;
    /**
     * True if the user is a priority speaker.
     *
     * @generated from protobuf field: optional bool priority_speaker = 18
     */
    prioritySpeaker?: boolean;
    /**
     * True if the user is currently recording.
     *
     * @generated from protobuf field: optional bool recording = 19
     */
    recording?: boolean;
    /**
     * A list of temporary access tokens to be respected when processing this request.
     *
     * @generated from protobuf field: repeated string temporary_access_tokens = 20
     */
    temporaryAccessTokens: string[];
    /**
     * A list of channels the user wants to start listening to.
     *
     * @generated from protobuf field: repeated uint32 listening_channel_add = 21
     */
    listeningChannelAdd: number[];
    /**
     * a list of channels the user does no longer want to listen to.
     *
     * @generated from protobuf field: repeated uint32 listening_channel_remove = 22
     */
    listeningChannelRemove: number[];
    /**
     * A list of volume adjustments the user has applied to listeners
     *
     * @generated from protobuf field: repeated MumbleProto.UserState.VolumeAdjustment listening_volume_adjustment = 23
     */
    listeningVolumeAdjustment: UserState_VolumeAdjustment[];
}
/**
 * @generated from protobuf message MumbleProto.UserState.VolumeAdjustment
 */
export interface UserState_VolumeAdjustment {
    /**
     * @generated from protobuf field: optional uint32 listening_channel = 1
     */
    listeningChannel?: number;
    /**
     * @generated from protobuf field: optional float volume_adjustment = 2
     */
    volumeAdjustment?: number;
}
/**
 * Relays information on the bans. The client may send the BanList message to
 * either modify the list of bans or query them from the server. The server
 * sends this list only after a client queries for it.
 *
 * @generated from protobuf message MumbleProto.BanList
 */
export interface BanList {
    /**
     * List of ban entries currently in place.
     *
     * @generated from protobuf field: repeated MumbleProto.BanList.BanEntry bans = 1
     */
    bans: BanList_BanEntry[];
    /**
     * True if the server should return the list, false if it should replace old
     * ban list with the one provided.
     *
     * @generated from protobuf field: optional bool query = 2 [default = false]
     */
    query?: boolean;
}
/**
 * @generated from protobuf message MumbleProto.BanList.BanEntry
 */
export interface BanList_BanEntry {
    /**
     * Banned IP address.
     *
     * @generated from protobuf field: required bytes address = 1
     */
    address: Uint8Array;
    /**
     * The length of the subnet mask for the ban.
     *
     * @generated from protobuf field: required uint32 mask = 2
     */
    mask: number;
    /**
     * User name for identification purposes (does not affect the ban).
     *
     * @generated from protobuf field: optional string name = 3
     */
    name?: string;
    /**
     * The certificate hash of the banned user.
     *
     * @generated from protobuf field: optional string hash = 4
     */
    hash?: string;
    /**
     * Reason for the ban (does not affect the ban).
     *
     * @generated from protobuf field: optional string reason = 5
     */
    reason?: string;
    /**
     * Ban start time.
     *
     * @generated from protobuf field: optional string start = 6
     */
    start?: string;
    /**
     * Ban duration in seconds.
     *
     * @generated from protobuf field: optional uint32 duration = 7
     */
    duration?: number;
}
/**
 * Used to send and broadcast text messages.
 *
 * @generated from protobuf message MumbleProto.TextMessage
 */
export interface TextMessage {
    /**
     * The message sender, identified by its session.
     *
     * @generated from protobuf field: optional uint32 actor = 1
     */
    actor?: number;
    /**
     * Target users for the message, identified by their session.
     *
     * @generated from protobuf field: repeated uint32 session = 2
     */
    session: number[];
    /**
     * The channels to which the message is sent, identified by their
     * channel_ids.
     *
     * @generated from protobuf field: repeated uint32 channel_id = 3
     */
    channelId: number[];
    /**
     * The root channels when sending message recursively to several channels,
     * identified by their channel_ids.
     *
     * @generated from protobuf field: repeated uint32 tree_id = 4
     */
    treeId: number[];
    /**
     * The UTF-8 encoded message. May be HTML if the server allows.
     *
     * @generated from protobuf field: required string message = 5
     */
    message: string;
}
/**
 * @generated from protobuf message MumbleProto.PermissionDenied
 */
export interface PermissionDenied {
    /**
     * The denied permission when type is Permission.
     *
     * @generated from protobuf field: optional uint32 permission = 1
     */
    permission?: number;
    /**
     * channel_id for the channel where the permission was denied when type is
     * Permission.
     *
     * @generated from protobuf field: optional uint32 channel_id = 2
     */
    channelId?: number;
    /**
     * The user who was denied permissions, identified by session.
     *
     * @generated from protobuf field: optional uint32 session = 3
     */
    session?: number;
    /**
     * Textual reason for the denial.
     *
     * @generated from protobuf field: optional string reason = 4
     */
    reason?: string;
    /**
     * Type of the denial.
     *
     * @generated from protobuf field: optional MumbleProto.PermissionDenied.DenyType type = 5
     */
    type?: PermissionDenied_DenyType;
    /**
     * The name that is invalid when type is UserName.
     *
     * @generated from protobuf field: optional string name = 6
     */
    name?: string;
}
/**
 * @generated from protobuf enum MumbleProto.PermissionDenied.DenyType
 */
export declare enum PermissionDenied_DenyType {
    /**
     * Operation denied for other reason, see reason field.
     *
     * @generated from protobuf enum value: Text = 0;
     */
    Text = 0,
    /**
     * Permissions were denied.
     *
     * @generated from protobuf enum value: Permission = 1;
     */
    Permission = 1,
    /**
     * Cannot modify SuperUser.
     *
     * @generated from protobuf enum value: SuperUser = 2;
     */
    SuperUser = 2,
    /**
     * Invalid channel name.
     *
     * @generated from protobuf enum value: ChannelName = 3;
     */
    ChannelName = 3,
    /**
     * Text message too long.
     *
     * @generated from protobuf enum value: TextTooLong = 4;
     */
    TextTooLong = 4,
    /**
     * The flux capacitor was spelled wrong.
     *
     * @generated from protobuf enum value: H9K = 5;
     */
    H9K = 5,
    /**
     * Operation not permitted in temporary channel.
     *
     * @generated from protobuf enum value: TemporaryChannel = 6;
     */
    TemporaryChannel = 6,
    /**
     * Operation requires certificate.
     *
     * @generated from protobuf enum value: MissingCertificate = 7;
     */
    MissingCertificate = 7,
    /**
     * Invalid username.
     *
     * @generated from protobuf enum value: UserName = 8;
     */
    UserName = 8,
    /**
     * Channel is full.
     *
     * @generated from protobuf enum value: ChannelFull = 9;
     */
    ChannelFull = 9,
    /**
     * Channels are nested too deeply.
     *
     * @generated from protobuf enum value: NestingLimit = 10;
     */
    NestingLimit = 10,
    /**
     * Maximum channel count reached.
     *
     * @generated from protobuf enum value: ChannelCountLimit = 11;
     */
    ChannelCountLimit = 11,
    /**
     * Amount of listener objects for this channel has been reached
     *
     * @generated from protobuf enum value: ChannelListenerLimit = 12;
     */
    ChannelListenerLimit = 12,
    /**
     * Amount of listener proxies for the user has been reached
     *
     * @generated from protobuf enum value: UserListenerLimit = 13;
     */
    UserListenerLimit = 13
}
/**
 * @generated from protobuf message MumbleProto.ACL
 */
export interface ACL {
    /**
     * Channel ID of the channel this message affects.
     *
     * @generated from protobuf field: required uint32 channel_id = 1
     */
    channelId: number;
    /**
     * True if the channel inherits its parent's ACLs.
     *
     * @generated from protobuf field: optional bool inherit_acls = 2 [default = true]
     */
    inheritAcls?: boolean;
    /**
     * User group specifications.
     *
     * @generated from protobuf field: repeated MumbleProto.ACL.ChanGroup groups = 3
     */
    groups: ACL_ChanGroup[];
    /**
     * ACL specifications.
     *
     * @generated from protobuf field: repeated MumbleProto.ACL.ChanACL acls = 4
     */
    acls: ACL_ChanACL[];
    /**
     * True if the message is a query for ACLs instead of setting them.
     *
     * @generated from protobuf field: optional bool query = 5 [default = false]
     */
    query?: boolean;
}
/**
 * @generated from protobuf message MumbleProto.ACL.ChanGroup
 */
export interface ACL_ChanGroup {
    /**
     * Name of the channel group, UTF-8 encoded.
     *
     * @generated from protobuf field: required string name = 1
     */
    name: string;
    /**
     * True if the group has been inherited from the parent (Read only).
     *
     * @generated from protobuf field: optional bool inherited = 2 [default = true]
     */
    inherited?: boolean;
    /**
     * True if the group members are inherited.
     *
     * @generated from protobuf field: optional bool inherit = 3 [default = true]
     */
    inherit?: boolean;
    /**
     * True if the group can be inherited by sub channels.
     *
     * @generated from protobuf field: optional bool inheritable = 4 [default = true]
     */
    inheritable?: boolean;
    /**
     * Users explicitly included in this group, identified by user_id.
     *
     * @generated from protobuf field: repeated uint32 add = 5
     */
    add: number[];
    /**
     * Users explicitly removed from this group in this channel if the group
     * has been inherited, identified by user_id.
     *
     * @generated from protobuf field: repeated uint32 remove = 6
     */
    remove: number[];
    /**
     * Users inherited, identified by user_id.
     *
     * @generated from protobuf field: repeated uint32 inherited_members = 7
     */
    inheritedMembers: number[];
}
/**
 * @generated from protobuf message MumbleProto.ACL.ChanACL
 */
export interface ACL_ChanACL {
    /**
     * True if this ACL applies to the current channel.
     *
     * @generated from protobuf field: optional bool apply_here = 1 [default = true]
     */
    applyHere?: boolean;
    /**
     * True if this ACL applies to the sub channels.
     *
     * @generated from protobuf field: optional bool apply_subs = 2 [default = true]
     */
    applySubs?: boolean;
    /**
     * True if the ACL has been inherited from the parent.
     *
     * @generated from protobuf field: optional bool inherited = 3 [default = true]
     */
    inherited?: boolean;
    /**
     * ID of the user that is affected by this ACL.
     *
     * @generated from protobuf field: optional uint32 user_id = 4
     */
    userId?: number;
    /**
     * ID of the group that is affected by this ACL.
     *
     * @generated from protobuf field: optional string group = 5
     */
    group?: string;
    /**
     * Bit flag field of the permissions granted by this ACL.
     *
     * @generated from protobuf field: optional uint32 grant = 6
     */
    grant?: number;
    /**
     * Bit flag field of the permissions denied by this ACL.
     *
     * @generated from protobuf field: optional uint32 deny = 7
     */
    deny?: number;
}
/**
 * Client may use this message to refresh its registered user information. The
 * client should fill the IDs or Names of the users it wants to refresh. The
 * server fills the missing parts and sends the message back.
 *
 * @generated from protobuf message MumbleProto.QueryUsers
 */
export interface QueryUsers {
    /**
     * user_ids.
     *
     * @generated from protobuf field: repeated uint32 ids = 1
     */
    ids: number[];
    /**
     * User names in the same order as ids.
     *
     * @generated from protobuf field: repeated string names = 2
     */
    names: string[];
}
/**
 * Used to initialize and resync the UDP encryption. Either side may request a
 * resync by sending the message without any values filled. The resync is
 * performed by sending the message with only the client or server nonce
 * filled.
 *
 * @generated from protobuf message MumbleProto.CryptSetup
 */
export interface CryptSetup {
    /**
     * Encryption key.
     *
     * @generated from protobuf field: optional bytes key = 1
     */
    key?: Uint8Array;
    /**
     * Client nonce.
     *
     * @generated from protobuf field: optional bytes client_nonce = 2
     */
    clientNonce?: Uint8Array;
    /**
     * Server nonce.
     *
     * @generated from protobuf field: optional bytes server_nonce = 3
     */
    serverNonce?: Uint8Array;
}
/**
 * Used to add or remove custom context menu item on client-side.
 *
 * @generated from protobuf message MumbleProto.ContextActionModify
 */
export interface ContextActionModify {
    /**
     * The action identifier. Used later to initiate an action.
     *
     * @generated from protobuf field: required string action = 1
     */
    action: string;
    /**
     * The display name of the action.
     *
     * @generated from protobuf field: optional string text = 2
     */
    text?: string;
    /**
     * Context bit flags defining where the action should be displayed.
     * Flags can be OR-ed to combine different types.
     *
     * @generated from protobuf field: optional uint32 context = 3
     */
    context?: number;
    /**
     * Choose either to add or to remove the context action.
     * Note: This field only exists after Mumble 1.2.4-beta1 release.
     *       The message will be recognized as Add regardless of this field
     *       before said release.
     *
     * @generated from protobuf field: optional MumbleProto.ContextActionModify.Operation operation = 4
     */
    operation?: ContextActionModify_Operation;
}
/**
 * @generated from protobuf enum MumbleProto.ContextActionModify.Context
 */
export declare enum ContextActionModify_Context {
    /**
     * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
     */
    UNSPECIFIED$ = 0,
    /**
     * Action is applicable to the server.
     *
     * @generated from protobuf enum value: Server = 1;
     */
    Server = 1,
    /**
     * Action can target a Channel.
     *
     * @generated from protobuf enum value: Channel = 2;
     */
    Channel = 2,
    /**
     * Action can target a User.
     *
     * @generated from protobuf enum value: User = 4;
     */
    User = 4
}
/**
 * @generated from protobuf enum MumbleProto.ContextActionModify.Operation
 */
export declare enum ContextActionModify_Operation {
    /**
     * @generated from protobuf enum value: Add = 0;
     */
    Add = 0,
    /**
     * @generated from protobuf enum value: Remove = 1;
     */
    Remove = 1
}
/**
 * Sent by the client when it wants to initiate a Context action.
 *
 * @generated from protobuf message MumbleProto.ContextAction
 */
export interface ContextAction {
    /**
     * The target User for the action, identified by session.
     *
     * @generated from protobuf field: optional uint32 session = 1
     */
    session?: number;
    /**
     * The target Channel for the action, identified by channel_id.
     *
     * @generated from protobuf field: optional uint32 channel_id = 2
     */
    channelId?: number;
    /**
     * The action that should be executed.
     *
     * @generated from protobuf field: required string action = 3
     */
    action: string;
}
/**
 * Lists the registered users.
 *
 * @generated from protobuf message MumbleProto.UserList
 */
export interface UserList {
    /**
     * A list of registered users.
     *
     * @generated from protobuf field: repeated MumbleProto.UserList.User users = 1
     */
    users: UserList_User[];
}
/**
 * @generated from protobuf message MumbleProto.UserList.User
 */
export interface UserList_User {
    /**
     * Registered user ID.
     *
     * @generated from protobuf field: required uint32 user_id = 1
     */
    userId: number;
    /**
     * Registered user name.
     *
     * @generated from protobuf field: optional string name = 2
     */
    name?: string;
    /**
     * @generated from protobuf field: optional string last_seen = 3
     */
    lastSeen?: string;
    /**
     * @generated from protobuf field: optional uint32 last_channel = 4
     */
    lastChannel?: number;
}
/**
 * Sent by the client when it wants to register or clear whisper targets.
 *
 * Note: The first available target ID is 1 as 0 is reserved for normal
 * talking. Maximum target ID is 30.
 *
 * @generated from protobuf message MumbleProto.VoiceTarget
 */
export interface VoiceTarget {
    /**
     * Voice target ID.
     *
     * @generated from protobuf field: optional uint32 id = 1
     */
    id?: number;
    /**
     * The receivers that this voice target includes.
     *
     * @generated from protobuf field: repeated MumbleProto.VoiceTarget.Target targets = 2
     */
    targets: VoiceTarget_Target[];
}
/**
 * @generated from protobuf message MumbleProto.VoiceTarget.Target
 */
export interface VoiceTarget_Target {
    /**
     * Users that are included as targets.
     *
     * @generated from protobuf field: repeated uint32 session = 1
     */
    session: number[];
    /**
     * Channel that is included as a target.
     *
     * @generated from protobuf field: optional uint32 channel_id = 2
     */
    channelId?: number;
    /**
     * ACL group that is included as a target.
     *
     * @generated from protobuf field: optional string group = 3
     */
    group?: string;
    /**
     * True if the voice should follow links from the specified channel.
     *
     * @generated from protobuf field: optional bool links = 4 [default = false]
     */
    links?: boolean;
    /**
     * True if the voice should also be sent to children of the specific
     * channel.
     *
     * @generated from protobuf field: optional bool children = 5 [default = false]
     */
    children?: boolean;
}
/**
 * Sent by the client when it wants permissions for a certain channel. Sent by
 * the server when it replies to the query or wants the user to resync all
 * channel permissions.
 *
 * @generated from protobuf message MumbleProto.PermissionQuery
 */
export interface PermissionQuery {
    /**
     * channel_id of the channel for which the permissions are queried.
     *
     * @generated from protobuf field: optional uint32 channel_id = 1
     */
    channelId?: number;
    /**
     * Channel permissions.
     *
     * @generated from protobuf field: optional uint32 permissions = 2
     */
    permissions?: number;
    /**
     * True if the client should drop its current permission information for all
     * channels.
     *
     * @generated from protobuf field: optional bool flush = 3 [default = false]
     */
    flush?: boolean;
}
/**
 * Sent by the server to notify the users of the version of the CELT codec they
 * should use. This may change during the connection when new users join.
 *
 * @generated from protobuf message MumbleProto.CodecVersion
 */
export interface CodecVersion {
    /**
     * The version of the CELT Alpha codec.
     *
     * @generated from protobuf field: required int32 alpha = 1
     */
    alpha: number;
    /**
     * The version of the CELT Beta codec.
     *
     * @generated from protobuf field: required int32 beta = 2
     */
    beta: number;
    /**
     * True if the user should prefer Alpha over Beta.
     *
     * @generated from protobuf field: required bool prefer_alpha = 3 [default = true]
     */
    preferAlpha: boolean;
    /**
     * @generated from protobuf field: optional bool opus = 4 [default = false]
     */
    opus?: boolean;
}
/**
 * Used to communicate user stats between the server and clients.
 *
 * @generated from protobuf message MumbleProto.UserStats
 */
export interface UserStats {
    /**
     * User whose stats these are.
     *
     * @generated from protobuf field: optional uint32 session = 1
     */
    session?: number;
    /**
     * True if the message contains only mutable stats (packets, ping).
     *
     * @generated from protobuf field: optional bool stats_only = 2 [default = false]
     */
    statsOnly?: boolean;
    /**
     * Full user certificate chain of the user certificate in DER format.
     *
     * @generated from protobuf field: repeated bytes certificates = 3
     */
    certificates: Uint8Array[];
    /**
     * Packet statistics for packets received from the client.
     *
     * @generated from protobuf field: optional MumbleProto.UserStats.Stats from_client = 4
     */
    fromClient?: UserStats_Stats;
    /**
     * Packet statistics for packets sent by the server.
     *
     * @generated from protobuf field: optional MumbleProto.UserStats.Stats from_server = 5
     */
    fromServer?: UserStats_Stats;
    /**
     * Amount of UDP packets sent.
     *
     * @generated from protobuf field: optional uint32 udp_packets = 6
     */
    udpPackets?: number;
    /**
     * Amount of TCP packets sent.
     *
     * @generated from protobuf field: optional uint32 tcp_packets = 7
     */
    tcpPackets?: number;
    /**
     * UDP ping average.
     *
     * @generated from protobuf field: optional float udp_ping_avg = 8
     */
    udpPingAvg?: number;
    /**
     * UDP ping variance.
     *
     * @generated from protobuf field: optional float udp_ping_var = 9
     */
    udpPingVar?: number;
    /**
     * TCP ping average.
     *
     * @generated from protobuf field: optional float tcp_ping_avg = 10
     */
    tcpPingAvg?: number;
    /**
     * TCP ping variance.
     *
     * @generated from protobuf field: optional float tcp_ping_var = 11
     */
    tcpPingVar?: number;
    /**
     * Client version.
     *
     * @generated from protobuf field: optional MumbleProto.Version version = 12
     */
    version?: Version;
    /**
     * A list of CELT bitstream version constants supported by the client of this
     * user.
     *
     * @generated from protobuf field: repeated int32 celt_versions = 13
     */
    celtVersions: number[];
    /**
     * Client IP address.
     *
     * @generated from protobuf field: optional bytes address = 14
     */
    address?: Uint8Array;
    /**
     * Bandwidth used by this client.
     *
     * @generated from protobuf field: optional uint32 bandwidth = 15
     */
    bandwidth?: number;
    /**
     * Connection duration.
     *
     * @generated from protobuf field: optional uint32 onlinesecs = 16
     */
    onlinesecs?: number;
    /**
     * Duration since last activity.
     *
     * @generated from protobuf field: optional uint32 idlesecs = 17
     */
    idlesecs?: number;
    /**
     * True if the user has a strong certificate.
     *
     * @generated from protobuf field: optional bool strong_certificate = 18 [default = false]
     */
    strongCertificate?: boolean;
    /**
     * @generated from protobuf field: optional bool opus = 19 [default = false]
     */
    opus?: boolean;
}
/**
 * @generated from protobuf message MumbleProto.UserStats.Stats
 */
export interface UserStats_Stats {
    /**
     * The amount of good packets received.
     *
     * @generated from protobuf field: optional uint32 good = 1
     */
    good?: number;
    /**
     * The amount of late packets received.
     *
     * @generated from protobuf field: optional uint32 late = 2
     */
    late?: number;
    /**
     * The amount of packets never received.
     *
     * @generated from protobuf field: optional uint32 lost = 3
     */
    lost?: number;
    /**
     * The amount of nonce resyncs.
     *
     * @generated from protobuf field: optional uint32 resync = 4
     */
    resync?: number;
}
/**
 * Used by the client to request binary data from the server. By default large
 * comments or textures are not sent within standard messages but instead the
 * hash is. If the client does not recognize the hash it may request the
 * resource when it needs it. The client does so by sending a RequestBlob
 * message with the correct fields filled with the user sessions or channel_ids
 * it wants to receive. The server replies to this by sending a new
 * UserState/ChannelState message with the resources filled even if they would
 * normally be transmitted as hashes.
 *
 * @generated from protobuf message MumbleProto.RequestBlob
 */
export interface RequestBlob {
    /**
     * sessions of the requested UserState textures.
     *
     * @generated from protobuf field: repeated uint32 session_texture = 1
     */
    sessionTexture: number[];
    /**
     * sessions of the requested UserState comments.
     *
     * @generated from protobuf field: repeated uint32 session_comment = 2
     */
    sessionComment: number[];
    /**
     * channel_ids of the requested ChannelState descriptions.
     *
     * @generated from protobuf field: repeated uint32 channel_description = 3
     */
    channelDescription: number[];
}
/**
 * Sent by the server when it informs the clients on server configuration
 * details.
 *
 * @generated from protobuf message MumbleProto.ServerConfig
 */
export interface ServerConfig {
    /**
     * The maximum bandwidth the clients should use.
     *
     * @generated from protobuf field: optional uint32 max_bandwidth = 1
     */
    maxBandwidth?: number;
    /**
     * Server welcome text.
     *
     * @generated from protobuf field: optional string welcome_text = 2
     */
    welcomeText?: string;
    /**
     * True if the server allows HTML.
     *
     * @generated from protobuf field: optional bool allow_html = 3
     */
    allowHtml?: boolean;
    /**
     * Maximum text message length.
     *
     * @generated from protobuf field: optional uint32 message_length = 4
     */
    messageLength?: number;
    /**
     * Maximum image message length.
     *
     * @generated from protobuf field: optional uint32 image_message_length = 5
     */
    imageMessageLength?: number;
    /**
     * The maximum number of users allowed on the server.
     *
     * @generated from protobuf field: optional uint32 max_users = 6
     */
    maxUsers?: number;
    /**
     * Whether using Mumble's recording feature is allowed on the server
     *
     * @generated from protobuf field: optional bool recording_allowed = 7
     */
    recordingAllowed?: boolean;
}
/**
 * Sent by the server to inform the clients of suggested client configuration
 * specified by the server administrator.
 *
 * @generated from protobuf message MumbleProto.SuggestConfig
 */
export interface SuggestConfig {
    /**
     * Suggested client version in the legacy format.
     *
     * @generated from protobuf field: optional uint32 version_v1 = 1
     */
    versionV1?: number;
    /**
     * Suggested client version in the new format.
     * Necessary since patch level may exceed 255. (See https://github.com/mumble-voip/mumble/issues/5827)
     *
     * @generated from protobuf field: optional uint64 version_v2 = 4
     */
    versionV2?: bigint;
    /**
     * True if the administrator suggests positional audio to be used on this
     * server.
     *
     * @generated from protobuf field: optional bool positional = 2
     */
    positional?: boolean;
    /**
     * True if the administrator suggests push to talk to be used on this server.
     *
     * @generated from protobuf field: optional bool push_to_talk = 3
     */
    pushToTalk?: boolean;
}
/**
 * Used to send plugin messages between clients
 *
 * @generated from protobuf message MumbleProto.PluginDataTransmission
 */
export interface PluginDataTransmission {
    /**
     * The session ID of the client this message was sent from
     *
     * @generated from protobuf field: optional uint32 senderSession = 1
     */
    senderSession?: number;
    /**
     * The session IDs of the clients that should receive this message
     *
     * @generated from protobuf field: repeated uint32 receiverSessions = 2 [packed = true]
     */
    receiverSessions: number[];
    /**
     * The data that is sent
     *
     * @generated from protobuf field: optional bytes data = 3
     */
    data?: Uint8Array;
    /**
     * The ID of the sent data. This will be used by plugins to check whether they will
     * process it or not
     *
     * @generated from protobuf field: optional string dataID = 4
     */
    dataID?: string;
}
declare class Version$Type extends MessageType<Version> {
    constructor();
    create(value?: PartialMessage<Version>): Version;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Version): Version;
    internalBinaryWrite(message: Version, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.Version
 */
export declare const Version: Version$Type;
declare class UDPTunnel$Type extends MessageType<UDPTunnel> {
    constructor();
    create(value?: PartialMessage<UDPTunnel>): UDPTunnel;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UDPTunnel): UDPTunnel;
    internalBinaryWrite(message: UDPTunnel, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.UDPTunnel
 */
export declare const UDPTunnel: UDPTunnel$Type;
declare class Authenticate$Type extends MessageType<Authenticate> {
    constructor();
    create(value?: PartialMessage<Authenticate>): Authenticate;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Authenticate): Authenticate;
    internalBinaryWrite(message: Authenticate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.Authenticate
 */
export declare const Authenticate: Authenticate$Type;
declare class Ping$Type extends MessageType<Ping> {
    constructor();
    create(value?: PartialMessage<Ping>): Ping;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Ping): Ping;
    internalBinaryWrite(message: Ping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.Ping
 */
export declare const Ping: Ping$Type;
declare class Reject$Type extends MessageType<Reject> {
    constructor();
    create(value?: PartialMessage<Reject>): Reject;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Reject): Reject;
    internalBinaryWrite(message: Reject, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.Reject
 */
export declare const Reject: Reject$Type;
declare class ServerSync$Type extends MessageType<ServerSync> {
    constructor();
    create(value?: PartialMessage<ServerSync>): ServerSync;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ServerSync): ServerSync;
    internalBinaryWrite(message: ServerSync, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.ServerSync
 */
export declare const ServerSync: ServerSync$Type;
declare class ChannelRemove$Type extends MessageType<ChannelRemove> {
    constructor();
    create(value?: PartialMessage<ChannelRemove>): ChannelRemove;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ChannelRemove): ChannelRemove;
    internalBinaryWrite(message: ChannelRemove, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.ChannelRemove
 */
export declare const ChannelRemove: ChannelRemove$Type;
declare class ChannelState$Type extends MessageType<ChannelState> {
    constructor();
    create(value?: PartialMessage<ChannelState>): ChannelState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ChannelState): ChannelState;
    internalBinaryWrite(message: ChannelState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.ChannelState
 */
export declare const ChannelState: ChannelState$Type;
declare class UserRemove$Type extends MessageType<UserRemove> {
    constructor();
    create(value?: PartialMessage<UserRemove>): UserRemove;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserRemove): UserRemove;
    internalBinaryWrite(message: UserRemove, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.UserRemove
 */
export declare const UserRemove: UserRemove$Type;
declare class UserState$Type extends MessageType<UserState> {
    constructor();
    create(value?: PartialMessage<UserState>): UserState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserState): UserState;
    internalBinaryWrite(message: UserState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message MumbleProto.UserState
 */
export declare const UserState: UserState$Type;
declare class UserState_VolumeAdjustment$Type extends MessageType<UserState_VolumeAdjustment> {
    constructor();
    create(value?: PartialMessage<UserState_VolumeAdjustment>): UserState_VolumeAdjustment;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserState_VolumeAdjustment): UserState_VolumeAdjustment;
    internalBinaryWrite(message: UserState_VolumeAdjustment, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWri