feat:

--ADDED MUMBLE server cap

MumbleServer/ACL.py

@@ -0,0 +1,59 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class ACL:
+    """
+    Access Control List for a channel. ACLs are defined per channel, and can be inherited from parent channels.
+    
+    Attributes
+    ----------
+    applyHere : bool
+        Does the ACL apply to this channel?
+    applySubs : bool
+        Does the ACL apply to subchannels?
+    inherited : bool
+        Is this ACL inherited from a parent channel? Read-only.
+    userid : int
+        ID of user this ACL applies to. -1 if using a group name.
+    group : str
+        Group this ACL applies to. Blank if using userid.
+    allow : int
+        Binary mask of privileges to allow.
+    deny : int
+        Binary mask of privileges to deny.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::ACL``.
+    """
+    applyHere: bool = False
+    applySubs: bool = False
+    inherited: bool = False
+    userid: int = 0
+    group: str = ""
+    allow: int = 0
+    deny: int = 0
+
+_MumbleServer_ACL_t = IcePy.defineStruct(
+    "::MumbleServer::ACL",
+    ACL,
+    (),
+    (
+        ("applyHere", (), IcePy._t_bool),
+        ("applySubs", (), IcePy._t_bool),
+        ("inherited", (), IcePy._t_bool),
+        ("userid", (), IcePy._t_int),
+        ("group", (), IcePy._t_string),
+        ("allow", (), IcePy._t_int),
+        ("deny", (), IcePy._t_int)
+    ))
+
+__all__ = ["ACL", "_MumbleServer_ACL_t"]

MumbleServer/ACLList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ACL import _MumbleServer_ACL_t
+
+_MumbleServer_ACLList_t = IcePy.defineSequence("::MumbleServer::ACLList", (), _MumbleServer_ACL_t)
+
+__all__ = ["_MumbleServer_ACLList_t"]

MumbleServer/Ban.py

@@ -0,0 +1,67 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.NetAddress import _MumbleServer_NetAddress_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Buffer
+
+
+@dataclass
+class Ban:
+    """
+    A single ip mask for a ban.
+    
+    Attributes
+    ----------
+    address : bytes
+        Address to ban.
+    bits : int
+        Number of bits in ban to apply.
+    name : str
+        Username associated with ban.
+    hash : str
+        Hash of banned user.
+    reason : str
+        Reason for ban.
+    start : int
+        Date ban was applied in unix time format.
+    duration : int
+        Duration of ban.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::Ban``.
+    """
+    address: bytes = field(default_factory=bytes)
+    bits: int = 0
+    name: str = ""
+    hash: str = ""
+    reason: str = ""
+    start: int = 0
+    duration: int = 0
+
+_MumbleServer_Ban_t = IcePy.defineStruct(
+    "::MumbleServer::Ban",
+    Ban,
+    (),
+    (
+        ("address", (), _MumbleServer_NetAddress_t),
+        ("bits", (), IcePy._t_int),
+        ("name", (), IcePy._t_string),
+        ("hash", (), IcePy._t_string),
+        ("reason", (), IcePy._t_string),
+        ("start", (), IcePy._t_int),
+        ("duration", (), IcePy._t_int)
+    ))
+
+__all__ = ["Ban", "_MumbleServer_Ban_t"]

MumbleServer/BanList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Ban import _MumbleServer_Ban_t
+
+_MumbleServer_BanList_t = IcePy.defineSequence("::MumbleServer::BanList", (), _MumbleServer_Ban_t)
+
+__all__ = ["_MumbleServer_BanList_t"]

MumbleServer/CertificateDer.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_CertificateDer_t = IcePy.defineSequence("::MumbleServer::CertificateDer", (), IcePy._t_byte)
+
+__all__ = ["_MumbleServer_CertificateDer_t"]

MumbleServer/CertificateList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.CertificateDer import _MumbleServer_CertificateDer_t
+
+_MumbleServer_CertificateList_t = IcePy.defineSequence("::MumbleServer::CertificateList", (), _MumbleServer_CertificateDer_t)
+
+__all__ = ["_MumbleServer_CertificateList_t"]

MumbleServer/Channel.py

@@ -0,0 +1,67 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.IntList import _MumbleServer_IntList_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Buffer
+
+
+@dataclass
+class Channel:
+    """
+    A channel.
+    
+    Attributes
+    ----------
+    id : int
+        Channel ID. This is unique per channel, and the root channel is always id 0.
+    name : str
+        Name of the channel. There can not be two channels with the same parent that has the same name.
+    parent : int
+        ID of parent channel, or -1 if this is the root channel.
+    links : list[int]
+        List of id of linked channels.
+    description : str
+        Description of channel. Shown as tooltip for this channel.
+    temporary : bool
+        Channel is temporary, and will be removed when the last user leaves it. Read-only.
+    position : int
+        Position of the channel which is used in Client for sorting.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::Channel``.
+    """
+    id: int = 0
+    name: str = ""
+    parent: int = 0
+    links: list[int] = field(default_factory=list)
+    description: str = ""
+    temporary: bool = False
+    position: int = 0
+
+_MumbleServer_Channel_t = IcePy.defineStruct(
+    "::MumbleServer::Channel",
+    Channel,
+    (),
+    (
+        ("id", (), IcePy._t_int),
+        ("name", (), IcePy._t_string),
+        ("parent", (), IcePy._t_int),
+        ("links", (), _MumbleServer_IntList_t),
+        ("description", (), IcePy._t_string),
+        ("temporary", (), IcePy._t_bool),
+        ("position", (), IcePy._t_int)
+    ))
+
+__all__ = ["Channel", "_MumbleServer_Channel_t"]

MumbleServer/ChannelInfo.py

@@ -0,0 +1,31 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class ChannelInfo(Enum):
+    """
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::MumbleServer::ChannelInfo``.
+    """
+
+    ChannelDescription = 0
+
+    ChannelPosition = 1
+
+_MumbleServer_ChannelInfo_t = IcePy.defineEnum(
+    "::MumbleServer::ChannelInfo",
+    ChannelInfo,
+    (),
+    {
+        0: ChannelInfo.ChannelDescription,
+        1: ChannelInfo.ChannelPosition,
+    }
+)
+
+__all__ = ["ChannelInfo", "_MumbleServer_ChannelInfo_t"]

MumbleServer/ChannelList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Channel import _MumbleServer_Channel_t
+
+_MumbleServer_ChannelList_t = IcePy.defineSequence("::MumbleServer::ChannelList", (), _MumbleServer_Channel_t)
+
+__all__ = ["_MumbleServer_ChannelList_t"]

MumbleServer/ChannelMap.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Channel import _MumbleServer_Channel_t
+
+_MumbleServer_ChannelMap_t = IcePy.defineDictionary("::MumbleServer::ChannelMap", (), IcePy._t_int, _MumbleServer_Channel_t)
+
+__all__ = ["_MumbleServer_ChannelMap_t"]

MumbleServer/ConfigMap.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ConfigMap_t = IcePy.defineDictionary("::MumbleServer::ConfigMap", (), IcePy._t_string, IcePy._t_string)
+
+__all__ = ["_MumbleServer_ConfigMap_t"]

MumbleServer/ContextChannel.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+ContextChannel = 2
+"""
+Context for actions in the Channel menu.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::ContextChannel``.
+"""
+
+__all__ = ["ContextChannel"]

MumbleServer/ContextServer.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+ContextServer = 1
+"""
+Context for actions in the Server menu.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::ContextServer``.
+"""
+
+__all__ = ["ContextServer"]

MumbleServer/ContextUser.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+ContextUser = 4
+"""
+Context for actions in the User menu.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::ContextUser``.
+"""
+
+__all__ = ["ContextUser"]

MumbleServer/DBState.py

@@ -0,0 +1,33 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class DBState(Enum):
+    """
+    Different states of the underlying database
+    
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::MumbleServer::DBState``.
+    """
+
+    Normal = 0
+
+    ReadOnly = 1
+
+_MumbleServer_DBState_t = IcePy.defineEnum(
+    "::MumbleServer::DBState",
+    DBState,
+    (),
+    {
+        0: DBState.Normal,
+        1: DBState.ReadOnly,
+    }
+)
+
+__all__ = ["DBState", "_MumbleServer_DBState_t"]

MumbleServer/Group.py

@@ -0,0 +1,67 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.IntList import _MumbleServer_IntList_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Buffer
+
+
+@dataclass
+class Group:
+    """
+    A group. Groups are defined per channel, and can inherit members from parent channels.
+    
+    Attributes
+    ----------
+    name : str
+        Group name
+    inherited : bool
+        Is this group inherited from a parent channel? Read-only.
+    inherit : bool
+        Does this group inherit members from parent channels?
+    inheritable : bool
+        Can subchannels inherit members from this group?
+    add : list[int]
+        List of users to add to the group.
+    remove : list[int]
+        List of inherited users to remove from the group.
+    members : list[int]
+        Current members of the group, including inherited members. Read-only.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::Group``.
+    """
+    name: str = ""
+    inherited: bool = False
+    inherit: bool = False
+    inheritable: bool = False
+    add: list[int] = field(default_factory=list)
+    remove: list[int] = field(default_factory=list)
+    members: list[int] = field(default_factory=list)
+
+_MumbleServer_Group_t = IcePy.defineStruct(
+    "::MumbleServer::Group",
+    Group,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("inherited", (), IcePy._t_bool),
+        ("inherit", (), IcePy._t_bool),
+        ("inheritable", (), IcePy._t_bool),
+        ("add", (), _MumbleServer_IntList_t),
+        ("remove", (), _MumbleServer_IntList_t),
+        ("members", (), _MumbleServer_IntList_t)
+    ))
+
+__all__ = ["Group", "_MumbleServer_Group_t"]

MumbleServer/GroupList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Group import _MumbleServer_Group_t
+
+_MumbleServer_GroupList_t = IcePy.defineSequence("::MumbleServer::GroupList", (), _MumbleServer_Group_t)
+
+__all__ = ["_MumbleServer_GroupList_t"]

MumbleServer/GroupNameList.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_GroupNameList_t = IcePy.defineSequence("::MumbleServer::GroupNameList", (), IcePy._t_string)
+
+__all__ = ["_MumbleServer_GroupNameList_t"]

MumbleServer/IdList.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_IdList_t = IcePy.defineSequence("::MumbleServer::IdList", (), IcePy._t_int)
+
+__all__ = ["_MumbleServer_IdList_t"]

MumbleServer/IdMap.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_IdMap_t = IcePy.defineDictionary("::MumbleServer::IdMap", (), IcePy._t_string, IcePy._t_int)
+
+__all__ = ["_MumbleServer_IdMap_t"]

MumbleServer/IntList.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_IntList_t = IcePy.defineSequence("::MumbleServer::IntList", (), IcePy._t_int)
+
+__all__ = ["_MumbleServer_IntList_t"]

MumbleServer/InternalErrorException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InternalErrorException(ServerException):
+    """
+    Thrown if the server encounters an internal error while processing the request
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InternalErrorException``.
+    """
+
+    _ice_id = "::MumbleServer::InternalErrorException"
+
+_MumbleServer_InternalErrorException_t = IcePy.defineException(
+    "::MumbleServer::InternalErrorException",
+    InternalErrorException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InternalErrorException, '_ice_type', _MumbleServer_InternalErrorException_t)
+
+__all__ = ["InternalErrorException", "_MumbleServer_InternalErrorException_t"]

MumbleServer/InvalidCallbackException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidCallbackException(ServerException):
+    """
+    This is thrown when you supply an invalid callback.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidCallbackException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidCallbackException"
+
+_MumbleServer_InvalidCallbackException_t = IcePy.defineException(
+    "::MumbleServer::InvalidCallbackException",
+    InvalidCallbackException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidCallbackException, '_ice_type', _MumbleServer_InvalidCallbackException_t)
+
+__all__ = ["InvalidCallbackException", "_MumbleServer_InvalidCallbackException_t"]

MumbleServer/InvalidChannelException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidChannelException(ServerException):
+    """
+    This is thrown when you specify an invalid channel id. This may happen if the channel was removed by another provess. It can also be thrown if you try to add an invalid channel.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidChannelException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidChannelException"
+
+_MumbleServer_InvalidChannelException_t = IcePy.defineException(
+    "::MumbleServer::InvalidChannelException",
+    InvalidChannelException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidChannelException, '_ice_type', _MumbleServer_InvalidChannelException_t)
+
+__all__ = ["InvalidChannelException", "_MumbleServer_InvalidChannelException_t"]

MumbleServer/InvalidInputDataException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidInputDataException(ServerException):
+    """
+    This is thrown when invalid input data was specified.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidInputDataException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidInputDataException"
+
+_MumbleServer_InvalidInputDataException_t = IcePy.defineException(
+    "::MumbleServer::InvalidInputDataException",
+    InvalidInputDataException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidInputDataException, '_ice_type', _MumbleServer_InvalidInputDataException_t)
+
+__all__ = ["InvalidInputDataException", "_MumbleServer_InvalidInputDataException_t"]

MumbleServer/InvalidListenerException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidListenerException(ServerException):
+    """
+    This is thrown when the referenced channel listener does not actually exist
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidListenerException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidListenerException"
+
+_MumbleServer_InvalidListenerException_t = IcePy.defineException(
+    "::MumbleServer::InvalidListenerException",
+    InvalidListenerException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidListenerException, '_ice_type', _MumbleServer_InvalidListenerException_t)
+
+__all__ = ["InvalidListenerException", "_MumbleServer_InvalidListenerException_t"]

MumbleServer/InvalidSecretException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidSecretException(ServerException):
+    """
+    This is thrown when you supply the wrong secret in the calling context.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidSecretException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidSecretException"
+
+_MumbleServer_InvalidSecretException_t = IcePy.defineException(
+    "::MumbleServer::InvalidSecretException",
+    InvalidSecretException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidSecretException, '_ice_type', _MumbleServer_InvalidSecretException_t)
+
+__all__ = ["InvalidSecretException", "_MumbleServer_InvalidSecretException_t"]

MumbleServer/InvalidServerException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidServerException(ServerException):
+    """
+    This is thrown when you try to do an operation on a server that does not exist. This may happen if someone has removed the server.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidServerException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidServerException"
+
+_MumbleServer_InvalidServerException_t = IcePy.defineException(
+    "::MumbleServer::InvalidServerException",
+    InvalidServerException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidServerException, '_ice_type', _MumbleServer_InvalidServerException_t)
+
+__all__ = ["InvalidServerException", "_MumbleServer_InvalidServerException_t"]

MumbleServer/InvalidSessionException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidSessionException(ServerException):
+    """
+    This is thrown when you specify an invalid session. This may happen if the user has disconnected since your last call to ``Server.getUsers``. See ``User.session``
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidSessionException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidSessionException"
+
+_MumbleServer_InvalidSessionException_t = IcePy.defineException(
+    "::MumbleServer::InvalidSessionException",
+    InvalidSessionException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidSessionException, '_ice_type', _MumbleServer_InvalidSessionException_t)
+
+__all__ = ["InvalidSessionException", "_MumbleServer_InvalidSessionException_t"]

MumbleServer/InvalidTextureException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidTextureException(ServerException):
+    """
+    This is thrown when you try to set an invalid texture.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidTextureException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidTextureException"
+
+_MumbleServer_InvalidTextureException_t = IcePy.defineException(
+    "::MumbleServer::InvalidTextureException",
+    InvalidTextureException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidTextureException, '_ice_type', _MumbleServer_InvalidTextureException_t)
+
+__all__ = ["InvalidTextureException", "_MumbleServer_InvalidTextureException_t"]

MumbleServer/InvalidUserException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidUserException(ServerException):
+    """
+    This is thrown when you specify an invalid userid.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::InvalidUserException``.
+    """
+
+    _ice_id = "::MumbleServer::InvalidUserException"
+
+_MumbleServer_InvalidUserException_t = IcePy.defineException(
+    "::MumbleServer::InvalidUserException",
+    InvalidUserException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(InvalidUserException, '_ice_type', _MumbleServer_InvalidUserException_t)
+
+__all__ = ["InvalidUserException", "_MumbleServer_InvalidUserException_t"]

MumbleServer/LogEntry.py

@@ -0,0 +1,39 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class LogEntry:
+    """
+    A entry in the log.
+    
+    Attributes
+    ----------
+    timestamp : int
+        Timestamp in UNIX time_t
+    txt : str
+        The log message.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::LogEntry``.
+    """
+    timestamp: int = 0
+    txt: str = ""
+
+_MumbleServer_LogEntry_t = IcePy.defineStruct(
+    "::MumbleServer::LogEntry",
+    LogEntry,
+    (),
+    (
+        ("timestamp", (), IcePy._t_int),
+        ("txt", (), IcePy._t_string)
+    ))
+
+__all__ = ["LogEntry", "_MumbleServer_LogEntry_t"]

MumbleServer/LogList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.LogEntry import _MumbleServer_LogEntry_t
+
+_MumbleServer_LogList_t = IcePy.defineSequence("::MumbleServer::LogList", (), _MumbleServer_LogEntry_t)
+
+__all__ = ["_MumbleServer_LogList_t"]

MumbleServer/Meta.py

@@ -0,0 +1,837 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.ConfigMap import _MumbleServer_ConfigMap_t
+
+from MumbleServer.DBState import _MumbleServer_DBState_t
+
+from MumbleServer.InvalidCallbackException import _MumbleServer_InvalidCallbackException_t
+
+from MumbleServer.InvalidSecretException import _MumbleServer_InvalidSecretException_t
+
+from MumbleServer.MetaCallback_forward import _MumbleServer_MetaCallbackPrx_t
+
+from MumbleServer.Meta_forward import _MumbleServer_MetaPrx_t
+
+from MumbleServer.ReadOnlyModeException import _MumbleServer_ReadOnlyModeException_t
+
+from MumbleServer.ServerList import _MumbleServer_ServerList_t
+
+from MumbleServer.Server_forward import _MumbleServer_ServerPrx_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from MumbleServer.DBState import DBState
+    from MumbleServer.MetaCallback import MetaCallbackPrx
+    from MumbleServer.Server import ServerPrx
+    from collections.abc import Awaitable
+    from collections.abc import Mapping
+    from collections.abc import Sequence
+
+
+class MetaPrx(ObjectPrx):
+    """
+    This is the meta interface. It is primarily used for retrieving the :class:`MumbleServer.ServerPrx` interfaces for each individual server.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::Meta``.
+    """
+
+    def getServer(self, id: int, context: dict[str, str] | None = None) -> ServerPrx | None:
+        """
+        Fetch interface to specific server.
+        
+        Parameters
+        ----------
+        id : int
+            Server ID. See ``Server.getId``.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        ServerPrx | None
+            Interface for specified server, or a null proxy if id is invalid.
+        """
+        return Meta._op_getServer.invoke(self, ((id, ), context))
+
+    def getServerAsync(self, id: int, context: dict[str, str] | None = None) -> Awaitable[ServerPrx | None]:
+        """
+        Fetch interface to specific server.
+        
+        Parameters
+        ----------
+        id : int
+            Server ID. See ``Server.getId``.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[ServerPrx | None]
+            Interface for specified server, or a null proxy if id is invalid.
+        """
+        return Meta._op_getServer.invokeAsync(self, ((id, ), context))
+
+    def newServer(self, context: dict[str, str] | None = None) -> ServerPrx | None:
+        """
+        Create a new server. Call ``Server.getId`` on the returned interface to find it's ID.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        ServerPrx | None
+            Interface for new server.
+        """
+        return Meta._op_newServer.invoke(self, ((), context))
+
+    def newServerAsync(self, context: dict[str, str] | None = None) -> Awaitable[ServerPrx | None]:
+        """
+        Create a new server. Call ``Server.getId`` on the returned interface to find it's ID.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[ServerPrx | None]
+            Interface for new server.
+        """
+        return Meta._op_newServer.invokeAsync(self, ((), context))
+
+    def getBootedServers(self, context: dict[str, str] | None = None) -> list[ServerPrx | None]:
+        """
+        Fetch list of all currently running servers.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        list[ServerPrx | None]
+            List of interfaces for running servers.
+        """
+        return Meta._op_getBootedServers.invoke(self, ((), context))
+
+    def getBootedServersAsync(self, context: dict[str, str] | None = None) -> Awaitable[list[ServerPrx | None]]:
+        """
+        Fetch list of all currently running servers.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[list[ServerPrx | None]]
+            List of interfaces for running servers.
+        """
+        return Meta._op_getBootedServers.invokeAsync(self, ((), context))
+
+    def getAllServers(self, context: dict[str, str] | None = None) -> list[ServerPrx | None]:
+        """
+        Fetch list of all defined servers.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        list[ServerPrx | None]
+            List of interfaces for all servers.
+        """
+        return Meta._op_getAllServers.invoke(self, ((), context))
+
+    def getAllServersAsync(self, context: dict[str, str] | None = None) -> Awaitable[list[ServerPrx | None]]:
+        """
+        Fetch list of all defined servers.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[list[ServerPrx | None]]
+            List of interfaces for all servers.
+        """
+        return Meta._op_getAllServers.invokeAsync(self, ((), context))
+
+    def getDefaultConf(self, context: dict[str, str] | None = None) -> dict[str, str]:
+        """
+        Fetch default configuration. This returns the configuration items that were set in the configuration file, or
+        the built-in default. The individual servers will use these values unless they have been overridden in the
+        server specific configuration. The only special case is the port, which defaults to the value defined here +
+        the servers ID - 1 (so that virtual server #1 uses the defined port, server #2 uses port+1 etc).
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        dict[str, str]
+            Default configuration of the servers.
+        """
+        return Meta._op_getDefaultConf.invoke(self, ((), context))
+
+    def getDefaultConfAsync(self, context: dict[str, str] | None = None) -> Awaitable[dict[str, str]]:
+        """
+        Fetch default configuration. This returns the configuration items that were set in the configuration file, or
+        the built-in default. The individual servers will use these values unless they have been overridden in the
+        server specific configuration. The only special case is the port, which defaults to the value defined here +
+        the servers ID - 1 (so that virtual server #1 uses the defined port, server #2 uses port+1 etc).
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[dict[str, str]]
+            Default configuration of the servers.
+        """
+        return Meta._op_getDefaultConf.invokeAsync(self, ((), context))
+
+    def getVersion(self, context: dict[str, str] | None = None) -> tuple[int, int, int, str]:
+        """
+        Fetch version of the server.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[int, int, int, str]
+        
+            A tuple containing:
+                - int Major version.
+                - int Minor version.
+                - int Patchlevel.
+                - str Textual representation of version. Note that this may not match the ``major``, ``minor`` and ``patch`` levels, as it
+                  may be simply the compile date or the SVN revision. This is usually the text you want to present to users.
+        """
+        return Meta._op_getVersion.invoke(self, ((), context))
+
+    def getVersionAsync(self, context: dict[str, str] | None = None) -> Awaitable[tuple[int, int, int, str]]:
+        """
+        Fetch version of the server.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[int, int, int, str]]
+        
+            A tuple containing:
+                - int Major version.
+                - int Minor version.
+                - int Patchlevel.
+                - str Textual representation of version. Note that this may not match the ``major``, ``minor`` and ``patch`` levels, as it
+                  may be simply the compile date or the SVN revision. This is usually the text you want to present to users.
+        """
+        return Meta._op_getVersion.invokeAsync(self, ((), context))
+
+    def addCallback(self, cb: MetaCallbackPrx | None, context: dict[str, str] | None = None) -> None:
+        """
+        Add a callback. The callback will receive notifications when servers are started or stopped.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface which will receive notifications.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Meta._op_addCallback.invoke(self, ((cb, ), context))
+
+    def addCallbackAsync(self, cb: MetaCallbackPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Add a callback. The callback will receive notifications when servers are started or stopped.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface which will receive notifications.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return Meta._op_addCallback.invokeAsync(self, ((cb, ), context))
+
+    def removeCallback(self, cb: MetaCallbackPrx | None, context: dict[str, str] | None = None) -> None:
+        """
+        Remove a callback.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface to be removed.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Meta._op_removeCallback.invoke(self, ((cb, ), context))
+
+    def removeCallbackAsync(self, cb: MetaCallbackPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Remove a callback.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface to be removed.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return Meta._op_removeCallback.invokeAsync(self, ((cb, ), context))
+
+    def getUptime(self, context: dict[str, str] | None = None) -> int:
+        """
+        Get the server's uptime.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            Uptime of the server in seconds
+        """
+        return Meta._op_getUptime.invoke(self, ((), context))
+
+    def getUptimeAsync(self, context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Get the server's uptime.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            Uptime of the server in seconds
+        """
+        return Meta._op_getUptime.invokeAsync(self, ((), context))
+
+    def getSlice(self, context: dict[str, str] | None = None) -> str:
+        """
+        Get slice file.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        str
+            Contents of the slice file server compiled with.
+        """
+        return Meta._op_getSlice.invoke(self, ((), context))
+
+    def getSliceAsync(self, context: dict[str, str] | None = None) -> Awaitable[str]:
+        """
+        Get slice file.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[str]
+            Contents of the slice file server compiled with.
+        """
+        return Meta._op_getSlice.invokeAsync(self, ((), context))
+
+    def getAssumedDatabaseState(self, context: dict[str, str] | None = None) -> DBState:
+        return Meta._op_getAssumedDatabaseState.invoke(self, ((), context))
+
+    def getAssumedDatabaseStateAsync(self, context: dict[str, str] | None = None) -> Awaitable[DBState]:
+        return Meta._op_getAssumedDatabaseState.invokeAsync(self, ((), context))
+
+    def setAssumedDatabaseState(self, state: DBState, context: dict[str, str] | None = None) -> None:
+        """
+        Sets the assumed state of the underlying database
+        
+        Parameters
+        ----------
+        state : DBState
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Meta._op_setAssumedDatabaseState.invoke(self, ((state, ), context))
+
+    def setAssumedDatabaseStateAsync(self, state: DBState, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Sets the assumed state of the underlying database
+        
+        Parameters
+        ----------
+        state : DBState
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return Meta._op_setAssumedDatabaseState.invokeAsync(self, ((state, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> MetaPrx | None:
+        return checkedCast(MetaPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[MetaPrx | None ]:
+        return checkedCastAsync(MetaPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> MetaPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> MetaPrx | None:
+        return uncheckedCast(MetaPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::Meta"
+
+IcePy.defineProxy("::MumbleServer::Meta", MetaPrx)
+
+class Meta(Object, ABC):
+    """
+    This is the meta interface. It is primarily used for retrieving the :class:`MumbleServer.ServerPrx` interfaces for each individual server.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::Meta``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::Meta", )
+    _op_getServer: IcePy.Operation
+    _op_newServer: IcePy.Operation
+    _op_getBootedServers: IcePy.Operation
+    _op_getAllServers: IcePy.Operation
+    _op_getDefaultConf: IcePy.Operation
+    _op_getVersion: IcePy.Operation
+    _op_addCallback: IcePy.Operation
+    _op_removeCallback: IcePy.Operation
+    _op_getUptime: IcePy.Operation
+    _op_getSlice: IcePy.Operation
+    _op_getAssumedDatabaseState: IcePy.Operation
+    _op_setAssumedDatabaseState: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::Meta"
+
+    @abstractmethod
+    def getServer(self, id: int, current: Current) -> ServerPrx | None | Awaitable[ServerPrx | None]:
+        """
+        Fetch interface to specific server.
+        
+        Parameters
+        ----------
+        id : int
+            Server ID. See ``Server.getId``.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        ServerPrx | None | Awaitable[ServerPrx | None]
+            Interface for specified server, or a null proxy if id is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def newServer(self, current: Current) -> ServerPrx | None | Awaitable[ServerPrx | None]:
+        """
+        Create a new server. Call ``Server.getId`` on the returned interface to find it's ID.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        ServerPrx | None | Awaitable[ServerPrx | None]
+            Interface for new server.
+        """
+        pass
+
+    @abstractmethod
+    def getBootedServers(self, current: Current) -> Sequence[ServerPrx | None] | Awaitable[Sequence[ServerPrx | None]]:
+        """
+        Fetch list of all currently running servers.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Sequence[ServerPrx | None] | Awaitable[Sequence[ServerPrx | None]]
+            List of interfaces for running servers.
+        """
+        pass
+
+    @abstractmethod
+    def getAllServers(self, current: Current) -> Sequence[ServerPrx | None] | Awaitable[Sequence[ServerPrx | None]]:
+        """
+        Fetch list of all defined servers.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Sequence[ServerPrx | None] | Awaitable[Sequence[ServerPrx | None]]
+            List of interfaces for all servers.
+        """
+        pass
+
+    @abstractmethod
+    def getDefaultConf(self, current: Current) -> Mapping[str, str] | Awaitable[Mapping[str, str]]:
+        """
+        Fetch default configuration. This returns the configuration items that were set in the configuration file, or
+        the built-in default. The individual servers will use these values unless they have been overridden in the
+        server specific configuration. The only special case is the port, which defaults to the value defined here +
+        the servers ID - 1 (so that virtual server #1 uses the defined port, server #2 uses port+1 etc).
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Mapping[str, str] | Awaitable[Mapping[str, str]]
+            Default configuration of the servers.
+        """
+        pass
+
+    @abstractmethod
+    def getVersion(self, current: Current) -> tuple[int, int, int, str] | Awaitable[tuple[int, int, int, str]]:
+        """
+        Fetch version of the server.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[int, int, int, str] | Awaitable[tuple[int, int, int, str]]
+        
+            A tuple containing:
+                - int Major version.
+                - int Minor version.
+                - int Patchlevel.
+                - str Textual representation of version. Note that this may not match the ``major``, ``minor`` and ``patch`` levels, as it
+                  may be simply the compile date or the SVN revision. This is usually the text you want to present to users.
+        """
+        pass
+
+    @abstractmethod
+    def addCallback(self, cb: MetaCallbackPrx | None, current: Current) -> None | Awaitable[None]:
+        """
+        Add a callback. The callback will receive notifications when servers are started or stopped.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface which will receive notifications.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def removeCallback(self, cb: MetaCallbackPrx | None, current: Current) -> None | Awaitable[None]:
+        """
+        Remove a callback.
+        
+        Parameters
+        ----------
+        cb : MetaCallbackPrx | None
+            Callback interface to be removed.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def getUptime(self, current: Current) -> int | Awaitable[int]:
+        """
+        Get the server's uptime.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            Uptime of the server in seconds
+        """
+        pass
+
+    @abstractmethod
+    def getSlice(self, current: Current) -> str | Awaitable[str]:
+        """
+        Get slice file.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        str | Awaitable[str]
+            Contents of the slice file server compiled with.
+        """
+        pass
+
+    @abstractmethod
+    def getAssumedDatabaseState(self, current: Current) -> DBState | Awaitable[DBState]:
+        pass
+
+    @abstractmethod
+    def setAssumedDatabaseState(self, state: DBState, current: Current) -> None | Awaitable[None]:
+        """
+        Sets the assumed state of the underlying database
+        
+        Parameters
+        ----------
+        state : DBState
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+Meta._op_getServer = IcePy.Operation(
+    "getServer",
+    "getServer",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (),
+    ((), _MumbleServer_ServerPrx_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_newServer = IcePy.Operation(
+    "newServer",
+    "newServer",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    ((), _MumbleServer_ServerPrx_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_getBootedServers = IcePy.Operation(
+    "getBootedServers",
+    "getBootedServers",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _MumbleServer_ServerList_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_getAllServers = IcePy.Operation(
+    "getAllServers",
+    "getAllServers",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _MumbleServer_ServerList_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_getDefaultConf = IcePy.Operation(
+    "getDefaultConf",
+    "getDefaultConf",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _MumbleServer_ConfigMap_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_getVersion = IcePy.Operation(
+    "getVersion",
+    "getVersion",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (((), IcePy._t_int, False, 0), ((), IcePy._t_int, False, 0), ((), IcePy._t_int, False, 0), ((), IcePy._t_string, False, 0)),
+    None,
+    ())
+
+Meta._op_addCallback = IcePy.Operation(
+    "addCallback",
+    "addCallback",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _MumbleServer_MetaCallbackPrx_t, False, 0),),
+    (),
+    None,
+    (_MumbleServer_InvalidCallbackException_t, _MumbleServer_InvalidSecretException_t))
+
+Meta._op_removeCallback = IcePy.Operation(
+    "removeCallback",
+    "removeCallback",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _MumbleServer_MetaCallbackPrx_t, False, 0),),
+    (),
+    None,
+    (_MumbleServer_InvalidCallbackException_t, _MumbleServer_InvalidSecretException_t))
+
+Meta._op_getUptime = IcePy.Operation(
+    "getUptime",
+    "getUptime",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+Meta._op_getSlice = IcePy.Operation(
+    "getSlice",
+    "getSlice",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), IcePy._t_string, False, 0),
+    ())
+
+Meta._op_getAssumedDatabaseState = IcePy.Operation(
+    "getAssumedDatabaseState",
+    "getAssumedDatabaseState",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _MumbleServer_DBState_t, False, 0),
+    (_MumbleServer_InvalidSecretException_t,))
+
+Meta._op_setAssumedDatabaseState = IcePy.Operation(
+    "setAssumedDatabaseState",
+    "setAssumedDatabaseState",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_DBState_t, False, 0),),
+    (),
+    None,
+    (_MumbleServer_InvalidSecretException_t, _MumbleServer_ReadOnlyModeException_t))
+
+__all__ = ["Meta", "MetaPrx", "_MumbleServer_MetaPrx_t"]

MumbleServer/MetaCallback.py

@@ -0,0 +1,242 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.MetaCallback_forward import _MumbleServer_MetaCallbackPrx_t
+
+from MumbleServer.Server_forward import _MumbleServer_ServerPrx_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from MumbleServer.Server import ServerPrx
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class MetaCallbackPrx(ObjectPrx):
+    """
+    Callback interface for Meta. You can supply an implementation of this to receive notifications
+    when servers are stopped or started.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::MetaCallback``.
+    
+    See Also
+    --------
+        :class:`MumbleServer.ServerCallbackPrx`
+        ``Meta.addCallback``
+    """
+
+    def started(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a server is started. The server is up and running when this event is sent, so all methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return MetaCallback._op_started.invoke(self, ((srv, ), context))
+
+    def startedAsync(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a server is started. The server is up and running when this event is sent, so all methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return MetaCallback._op_started.invokeAsync(self, ((srv, ), context))
+
+    def stopped(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return MetaCallback._op_stopped.invoke(self, ((srv, ), context))
+
+    def stoppedAsync(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return MetaCallback._op_stopped.invokeAsync(self, ((srv, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> MetaCallbackPrx | None:
+        return checkedCast(MetaCallbackPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[MetaCallbackPrx | None ]:
+        return checkedCastAsync(MetaCallbackPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> MetaCallbackPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> MetaCallbackPrx | None:
+        return uncheckedCast(MetaCallbackPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::MetaCallback"
+
+IcePy.defineProxy("::MumbleServer::MetaCallback", MetaCallbackPrx)
+
+class MetaCallback(Object, ABC):
+    """
+    Callback interface for Meta. You can supply an implementation of this to receive notifications
+    when servers are stopped or started.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::MetaCallback``.
+    
+    See Also
+    --------
+        :class:`MumbleServer.ServerCallbackPrx`
+        ``Meta.addCallback``
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::MetaCallback", )
+    _op_started: IcePy.Operation
+    _op_stopped: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::MetaCallback"
+
+    @abstractmethod
+    def started(self, srv: ServerPrx | None, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a server is started. The server is up and running when this event is sent, so all methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def stopped(self, srv: ServerPrx | None, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
+        need a running server will work.
+        
+        Parameters
+        ----------
+        srv : ServerPrx | None
+            Interface for started server.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+MetaCallback._op_started = IcePy.Operation(
+    "started",
+    "started",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _MumbleServer_ServerPrx_t, False, 0),),
+    (),
+    None,
+    ())
+
+MetaCallback._op_stopped = IcePy.Operation(
+    "stopped",
+    "stopped",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _MumbleServer_ServerPrx_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["MetaCallback", "MetaCallbackPrx", "_MumbleServer_MetaCallbackPrx_t"]

MumbleServer/MetaCallback_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_MetaCallbackPrx_t = IcePy.declareProxy("::MumbleServer::MetaCallback")
+
+__all__ = ["_MumbleServer_MetaCallbackPrx_t"]

MumbleServer/Meta_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_MetaPrx_t = IcePy.declareProxy("::MumbleServer::Meta")
+
+__all__ = ["_MumbleServer_MetaPrx_t"]

MumbleServer/NameList.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_NameList_t = IcePy.defineSequence("::MumbleServer::NameList", (), IcePy._t_string)
+
+__all__ = ["_MumbleServer_NameList_t"]

MumbleServer/NameMap.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_NameMap_t = IcePy.defineDictionary("::MumbleServer::NameMap", (), IcePy._t_int, IcePy._t_string)
+
+__all__ = ["_MumbleServer_NameMap_t"]

MumbleServer/NestingLimitException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class NestingLimitException(ServerException):
+    """
+    This is thrown when the channel operation would exceed the channel nesting limit
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::NestingLimitException``.
+    """
+
+    _ice_id = "::MumbleServer::NestingLimitException"
+
+_MumbleServer_NestingLimitException_t = IcePy.defineException(
+    "::MumbleServer::NestingLimitException",
+    NestingLimitException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(NestingLimitException, '_ice_type', _MumbleServer_NestingLimitException_t)
+
+__all__ = ["NestingLimitException", "_MumbleServer_NestingLimitException_t"]

MumbleServer/NetAddress.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_NetAddress_t = IcePy.defineSequence("::MumbleServer::NetAddress", (), IcePy._t_byte)
+
+__all__ = ["_MumbleServer_NetAddress_t"]

MumbleServer/PermissionBan.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionBan = 131072
+"""
+Ban user from server. Only valid on root channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionBan``.
+"""
+
+__all__ = ["PermissionBan"]

MumbleServer/PermissionEnter.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionEnter = 4
+"""
+Enter channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionEnter``.
+"""
+
+__all__ = ["PermissionEnter"]

MumbleServer/PermissionKick.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionKick = 65536
+"""
+Kick user from server. Only valid on root channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionKick``.
+"""
+
+__all__ = ["PermissionKick"]

MumbleServer/PermissionLinkChannel.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionLinkChannel = 128
+"""
+Link this channel. You need this permission in both the source and destination channel to link channels, or in either channel to unlink them.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionLinkChannel``.
+"""
+
+__all__ = ["PermissionLinkChannel"]

MumbleServer/PermissionMakeChannel.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionMakeChannel = 64
+"""
+Make new channel as a subchannel of this channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionMakeChannel``.
+"""
+
+__all__ = ["PermissionMakeChannel"]

MumbleServer/PermissionMakeTempChannel.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionMakeTempChannel = 1024
+"""
+Make new temporary channel as a subchannel of this channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionMakeTempChannel``.
+"""
+
+__all__ = ["PermissionMakeTempChannel"]

MumbleServer/PermissionMove.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionMove = 32
+"""
+Move users from channel. You need this permission in both the source and destination channel to move another user.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionMove``.
+"""
+
+__all__ = ["PermissionMove"]

MumbleServer/PermissionMuteDeafen.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionMuteDeafen = 16
+"""
+Mute and deafen other users in this channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionMuteDeafen``.
+"""
+
+__all__ = ["PermissionMuteDeafen"]

MumbleServer/PermissionRegister.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionRegister = 262144
+"""
+Register and unregister users. Only valid on root channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionRegister``.
+"""
+
+__all__ = ["PermissionRegister"]

MumbleServer/PermissionRegisterSelf.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionRegisterSelf = 524288
+"""
+Register and unregister users. Only valid on root channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionRegisterSelf``.
+"""
+
+__all__ = ["PermissionRegisterSelf"]

MumbleServer/PermissionSpeak.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionSpeak = 8
+"""
+Speak in channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionSpeak``.
+"""
+
+__all__ = ["PermissionSpeak"]

MumbleServer/PermissionTextMessage.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionTextMessage = 512
+"""
+Send text message to channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionTextMessage``.
+"""
+
+__all__ = ["PermissionTextMessage"]

MumbleServer/PermissionTraverse.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionTraverse = 2
+"""
+Traverse channel. Without this, a client cannot reach subchannels, no matter which privileges he has there.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionTraverse``.
+"""
+
+__all__ = ["PermissionTraverse"]

MumbleServer/PermissionWhisper.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionWhisper = 256
+"""
+Whisper to channel. This is different from Speak, so you can set up different permissions.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionWhisper``.
+"""
+
+__all__ = ["PermissionWhisper"]

MumbleServer/PermissionWrite.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+PermissionWrite = 1
+"""
+Write access to channel control. Implies all other permissions (except Speak).
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::PermissionWrite``.
+"""
+
+__all__ = ["PermissionWrite"]

MumbleServer/ReadOnlyModeException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ReadOnlyModeException(ServerException):
+    """
+    This is thrown when the server has its database in read-only mode and whatever you requested is incompatible with that.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::ReadOnlyModeException``.
+    """
+
+    _ice_id = "::MumbleServer::ReadOnlyModeException"
+
+_MumbleServer_ReadOnlyModeException_t = IcePy.defineException(
+    "::MumbleServer::ReadOnlyModeException",
+    ReadOnlyModeException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(ReadOnlyModeException, '_ice_type', _MumbleServer_ReadOnlyModeException_t)
+
+__all__ = ["ReadOnlyModeException", "_MumbleServer_ReadOnlyModeException_t"]

MumbleServer/ResetUserContent.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+
+ResetUserContent = 1048576
+"""
+Reset the comment or avatar of a user. Only valid on root channel.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::MumbleServer::ResetUserContent``.
+"""
+
+__all__ = ["ResetUserContent"]

MumbleServer/ServerAuthenticator.py

@@ -0,0 +1,531 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.CertificateList import _MumbleServer_CertificateList_t
+
+from MumbleServer.GroupNameList import _MumbleServer_GroupNameList_t
+
+from MumbleServer.ServerAuthenticator_forward import _MumbleServer_ServerAuthenticatorPrx_t
+
+from MumbleServer.Texture import _MumbleServer_Texture_t
+
+from MumbleServer.UserInfoMap import _MumbleServer_UserInfoMap_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from MumbleServer.UserInfo import UserInfo
+    from collections.abc import Awaitable
+    from collections.abc import Buffer
+    from collections.abc import Mapping
+    from collections.abc import Sequence
+
+
+class ServerAuthenticatorPrx(ObjectPrx):
+    """
+    Callback interface for server authentication. You need to supply one of these for ``Server.setAuthenticator``.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that unlike :class:`MumbleServer.ServerCallbackPrx` and :class:`MumbleServer.ServerContextCallbackPrx`, these methods are called
+    synchronously. If the response lags, the entire server will lag.
+    Also note that, as the method calls are synchronous, making a call to :class:`MumbleServer.ServerPrx` or :class:`MumbleServer.MetaPrx` will
+    deadlock the server.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::ServerAuthenticator``.
+    """
+
+    def authenticate(self, name: str, pw: str, certificates: Sequence[Sequence[int] | bytes | Buffer], certhash: str, certstrong: bool, context: dict[str, str] | None = None) -> tuple[int, str, list[str]]:
+        """
+        Called to authenticate a user. If you do not know the username in question, always return -2 from this
+        method to fall through to normal database authentication.
+        Note that if authentication succeeds, the server will create a record of the user in it's database, reserving
+        the username and id so it cannot be used for normal database authentication.
+        The data in the certificate (name, email addresses etc), as well as the list of signing certificates,
+        should only be trusted if certstrong is true.
+        
+        Internally, the server treats usernames as case-insensitive. It is recommended
+        that authenticators do the same. the server checks if a username is in use when
+        a user connects. If the connecting user is registered, the other username is
+        kicked. If the connecting user is not registered, the connecting user is not
+        allowed to join the server.
+        
+        Parameters
+        ----------
+        name : str
+            Username to authenticate.
+        pw : str
+            Password to authenticate with.
+        certificates : Sequence[Sequence[int] | bytes | Buffer]
+            List of der encoded certificates the user connected with.
+        certhash : str
+            Hash of user certificate, as used by the server internally when matching.
+        certstrong : bool
+            True if certificate was valid and signed by a trusted CA.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[int, str, list[str]]
+        
+            A tuple containing:
+                - int UserID of authenticated user, -1 for authentication failures, -2 for unknown user (fallthrough),
+                  -3 for authentication failures where the data could (temporarily) not be verified.
+                - str Set this to change the username from the supplied one.
+                - list[str] List of groups on the root channel that the user will be added to for the duration of the connection.
+        """
+        return ServerAuthenticator._op_authenticate.invoke(self, ((name, pw, certificates, certhash, certstrong), context))
+
+    def authenticateAsync(self, name: str, pw: str, certificates: Sequence[Sequence[int] | bytes | Buffer], certhash: str, certstrong: bool, context: dict[str, str] | None = None) -> Awaitable[tuple[int, str, list[str]]]:
+        """
+        Called to authenticate a user. If you do not know the username in question, always return -2 from this
+        method to fall through to normal database authentication.
+        Note that if authentication succeeds, the server will create a record of the user in it's database, reserving
+        the username and id so it cannot be used for normal database authentication.
+        The data in the certificate (name, email addresses etc), as well as the list of signing certificates,
+        should only be trusted if certstrong is true.
+        
+        Internally, the server treats usernames as case-insensitive. It is recommended
+        that authenticators do the same. the server checks if a username is in use when
+        a user connects. If the connecting user is registered, the other username is
+        kicked. If the connecting user is not registered, the connecting user is not
+        allowed to join the server.
+        
+        Parameters
+        ----------
+        name : str
+            Username to authenticate.
+        pw : str
+            Password to authenticate with.
+        certificates : Sequence[Sequence[int] | bytes | Buffer]
+            List of der encoded certificates the user connected with.
+        certhash : str
+            Hash of user certificate, as used by the server internally when matching.
+        certstrong : bool
+            True if certificate was valid and signed by a trusted CA.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[int, str, list[str]]]
+        
+            A tuple containing:
+                - int UserID of authenticated user, -1 for authentication failures, -2 for unknown user (fallthrough),
+                  -3 for authentication failures where the data could (temporarily) not be verified.
+                - str Set this to change the username from the supplied one.
+                - list[str] List of groups on the root channel that the user will be added to for the duration of the connection.
+        """
+        return ServerAuthenticator._op_authenticate.invokeAsync(self, ((name, pw, certificates, certhash, certstrong), context))
+
+    def getInfo(self, id: int, context: dict[str, str] | None = None) -> tuple[bool, dict[UserInfo, str]]:
+        """
+        Fetch information about a user. This is used to retrieve information like email address, keyhash etc. If you
+        want the server to take care of this information itself, simply return false to fall through.
+        
+        Parameters
+        ----------
+        id : int
+            User id.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[bool, dict[UserInfo, str]]
+        
+            A tuple containing:
+                - bool true if information is present, false to fall through.
+                - dict[UserInfo, str] Information about user. This needs to include at least "name".
+        """
+        return ServerAuthenticator._op_getInfo.invoke(self, ((id, ), context))
+
+    def getInfoAsync(self, id: int, context: dict[str, str] | None = None) -> Awaitable[tuple[bool, dict[UserInfo, str]]]:
+        """
+        Fetch information about a user. This is used to retrieve information like email address, keyhash etc. If you
+        want the server to take care of this information itself, simply return false to fall through.
+        
+        Parameters
+        ----------
+        id : int
+            User id.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[bool, dict[UserInfo, str]]]
+        
+            A tuple containing:
+                - bool true if information is present, false to fall through.
+                - dict[UserInfo, str] Information about user. This needs to include at least "name".
+        """
+        return ServerAuthenticator._op_getInfo.invokeAsync(self, ((id, ), context))
+
+    def nameToId(self, name: str, context: dict[str, str] | None = None) -> int:
+        """
+        Map a name to a user id.
+        
+        Parameters
+        ----------
+        name : str
+            Username to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            User id or -2 for unknown name.
+        """
+        return ServerAuthenticator._op_nameToId.invoke(self, ((name, ), context))
+
+    def nameToIdAsync(self, name: str, context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Map a name to a user id.
+        
+        Parameters
+        ----------
+        name : str
+            Username to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            User id or -2 for unknown name.
+        """
+        return ServerAuthenticator._op_nameToId.invokeAsync(self, ((name, ), context))
+
+    def idToName(self, id: int, context: dict[str, str] | None = None) -> str:
+        """
+        Map a user id to a username.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        str
+            Name of user or empty string for unknown id.
+        """
+        return ServerAuthenticator._op_idToName.invoke(self, ((id, ), context))
+
+    def idToNameAsync(self, id: int, context: dict[str, str] | None = None) -> Awaitable[str]:
+        """
+        Map a user id to a username.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[str]
+            Name of user or empty string for unknown id.
+        """
+        return ServerAuthenticator._op_idToName.invokeAsync(self, ((id, ), context))
+
+    def idToTexture(self, id: int, context: dict[str, str] | None = None) -> bytes:
+        """
+        Map a user to a custom Texture.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        bytes
+            User texture or an empty texture for unknown users or users without textures.
+        """
+        return ServerAuthenticator._op_idToTexture.invoke(self, ((id, ), context))
+
+    def idToTextureAsync(self, id: int, context: dict[str, str] | None = None) -> Awaitable[bytes]:
+        """
+        Map a user to a custom Texture.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[bytes]
+            User texture or an empty texture for unknown users or users without textures.
+        """
+        return ServerAuthenticator._op_idToTexture.invokeAsync(self, ((id, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ServerAuthenticatorPrx | None:
+        return checkedCast(ServerAuthenticatorPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ServerAuthenticatorPrx | None ]:
+        return checkedCastAsync(ServerAuthenticatorPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ServerAuthenticatorPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ServerAuthenticatorPrx | None:
+        return uncheckedCast(ServerAuthenticatorPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerAuthenticator"
+
+IcePy.defineProxy("::MumbleServer::ServerAuthenticator", ServerAuthenticatorPrx)
+
+class ServerAuthenticator(Object, ABC):
+    """
+    Callback interface for server authentication. You need to supply one of these for ``Server.setAuthenticator``.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that unlike :class:`MumbleServer.ServerCallbackPrx` and :class:`MumbleServer.ServerContextCallbackPrx`, these methods are called
+    synchronously. If the response lags, the entire server will lag.
+    Also note that, as the method calls are synchronous, making a call to :class:`MumbleServer.ServerPrx` or :class:`MumbleServer.MetaPrx` will
+    deadlock the server.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::ServerAuthenticator``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::ServerAuthenticator", )
+    _op_authenticate: IcePy.Operation
+    _op_getInfo: IcePy.Operation
+    _op_nameToId: IcePy.Operation
+    _op_idToName: IcePy.Operation
+    _op_idToTexture: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerAuthenticator"
+
+    @abstractmethod
+    def authenticate(self, name: str, pw: str, certificates: list[bytes], certhash: str, certstrong: bool, current: Current) -> tuple[int, str, Sequence[str]] | Awaitable[tuple[int, str, Sequence[str]]]:
+        """
+        Called to authenticate a user. If you do not know the username in question, always return -2 from this
+        method to fall through to normal database authentication.
+        Note that if authentication succeeds, the server will create a record of the user in it's database, reserving
+        the username and id so it cannot be used for normal database authentication.
+        The data in the certificate (name, email addresses etc), as well as the list of signing certificates,
+        should only be trusted if certstrong is true.
+        
+        Internally, the server treats usernames as case-insensitive. It is recommended
+        that authenticators do the same. the server checks if a username is in use when
+        a user connects. If the connecting user is registered, the other username is
+        kicked. If the connecting user is not registered, the connecting user is not
+        allowed to join the server.
+        
+        Parameters
+        ----------
+        name : str
+            Username to authenticate.
+        pw : str
+            Password to authenticate with.
+        certificates : list[bytes]
+            List of der encoded certificates the user connected with.
+        certhash : str
+            Hash of user certificate, as used by the server internally when matching.
+        certstrong : bool
+            True if certificate was valid and signed by a trusted CA.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[int, str, Sequence[str]] | Awaitable[tuple[int, str, Sequence[str]]]
+        
+            A tuple containing:
+                - int UserID of authenticated user, -1 for authentication failures, -2 for unknown user (fallthrough),
+                  -3 for authentication failures where the data could (temporarily) not be verified.
+                - str Set this to change the username from the supplied one.
+                - Sequence[str] List of groups on the root channel that the user will be added to for the duration of the connection.
+        """
+        pass
+
+    @abstractmethod
+    def getInfo(self, id: int, current: Current) -> tuple[bool, Mapping[UserInfo, str]] | Awaitable[tuple[bool, Mapping[UserInfo, str]]]:
+        """
+        Fetch information about a user. This is used to retrieve information like email address, keyhash etc. If you
+        want the server to take care of this information itself, simply return false to fall through.
+        
+        Parameters
+        ----------
+        id : int
+            User id.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[bool, Mapping[UserInfo, str]] | Awaitable[tuple[bool, Mapping[UserInfo, str]]]
+        
+            A tuple containing:
+                - bool true if information is present, false to fall through.
+                - Mapping[UserInfo, str] Information about user. This needs to include at least "name".
+        """
+        pass
+
+    @abstractmethod
+    def nameToId(self, name: str, current: Current) -> int | Awaitable[int]:
+        """
+        Map a name to a user id.
+        
+        Parameters
+        ----------
+        name : str
+            Username to map.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            User id or -2 for unknown name.
+        """
+        pass
+
+    @abstractmethod
+    def idToName(self, id: int, current: Current) -> str | Awaitable[str]:
+        """
+        Map a user id to a username.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        str | Awaitable[str]
+            Name of user or empty string for unknown id.
+        """
+        pass
+
+    @abstractmethod
+    def idToTexture(self, id: int, current: Current) -> Sequence[int] | bytes | Buffer | Awaitable[Sequence[int] | bytes | Buffer]:
+        """
+        Map a user to a custom Texture.
+        
+        Parameters
+        ----------
+        id : int
+            User id to map.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Sequence[int] | bytes | Buffer | Awaitable[Sequence[int] | bytes | Buffer]
+            User texture or an empty texture for unknown users or users without textures.
+        """
+        pass
+
+ServerAuthenticator._op_authenticate = IcePy.Operation(
+    "authenticate",
+    "authenticate",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0), ((), _MumbleServer_CertificateList_t, False, 0), ((), IcePy._t_string, False, 0), ((), IcePy._t_bool, False, 0)),
+    (((), IcePy._t_string, False, 0), ((), _MumbleServer_GroupNameList_t, False, 0)),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+ServerAuthenticator._op_getInfo = IcePy.Operation(
+    "getInfo",
+    "getInfo",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (((), _MumbleServer_UserInfoMap_t, False, 0),),
+    ((), IcePy._t_bool, False, 0),
+    ())
+
+ServerAuthenticator._op_nameToId = IcePy.Operation(
+    "nameToId",
+    "nameToId",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+ServerAuthenticator._op_idToName = IcePy.Operation(
+    "idToName",
+    "idToName",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (),
+    ((), IcePy._t_string, False, 0),
+    ())
+
+ServerAuthenticator._op_idToTexture = IcePy.Operation(
+    "idToTexture",
+    "idToTexture",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (),
+    ((), _MumbleServer_Texture_t, False, 0),
+    ())
+
+__all__ = ["ServerAuthenticator", "ServerAuthenticatorPrx", "_MumbleServer_ServerAuthenticatorPrx_t"]

MumbleServer/ServerAuthenticator_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ServerAuthenticatorPrx_t = IcePy.declareProxy("::MumbleServer::ServerAuthenticator")
+
+__all__ = ["_MumbleServer_ServerAuthenticatorPrx_t"]

MumbleServer/ServerBootedException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ServerBootedException(ServerException):
+    """
+    This happens if you try to fetch user or channel state on a stopped server, if you try to stop an already stopped server or start an already started server.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::ServerBootedException``.
+    """
+
+    _ice_id = "::MumbleServer::ServerBootedException"
+
+_MumbleServer_ServerBootedException_t = IcePy.defineException(
+    "::MumbleServer::ServerBootedException",
+    ServerBootedException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(ServerBootedException, '_ice_type', _MumbleServer_ServerBootedException_t)
+
+__all__ = ["ServerBootedException", "_MumbleServer_ServerBootedException_t"]

MumbleServer/ServerCallback.py

@@ -0,0 +1,565 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.Channel import _MumbleServer_Channel_t
+
+from MumbleServer.ServerCallback_forward import _MumbleServer_ServerCallbackPrx_t
+
+from MumbleServer.TextMessage import _MumbleServer_TextMessage_t
+
+from MumbleServer.User import _MumbleServer_User_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from MumbleServer.Channel import Channel
+    from MumbleServer.TextMessage import TextMessage
+    from MumbleServer.User import User
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class ServerCallbackPrx(ObjectPrx):
+    """
+    Callback interface for servers. You can supply an implementation of this to receive notification
+    messages from the server.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    Note that callbacks are removed when a server is stopped, so you should have a callback for
+    ``MetaCallback.started`` which calls ``Server.addCallback``.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::ServerCallback``.
+    
+    See Also
+    --------
+        :class:`MumbleServer.MetaCallbackPrx`
+        ``Server.addCallback``
+    """
+
+    def userConnected(self, state: User, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a user connects to the server.
+        
+        Parameters
+        ----------
+        state : User
+            State of connected user.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_userConnected.invoke(self, ((state, ), context))
+
+    def userConnectedAsync(self, state: User, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a user connects to the server.
+        
+        Parameters
+        ----------
+        state : User
+            State of connected user.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_userConnected.invokeAsync(self, ((state, ), context))
+
+    def userDisconnected(self, state: User, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a user disconnects from the server. The user has already been removed, so you can no longer use methods like ``Server.getState``
+        to retrieve the user's state.
+        
+        Parameters
+        ----------
+        state : User
+            State of disconnected user.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_userDisconnected.invoke(self, ((state, ), context))
+
+    def userDisconnectedAsync(self, state: User, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a user disconnects from the server. The user has already been removed, so you can no longer use methods like ``Server.getState``
+        to retrieve the user's state.
+        
+        Parameters
+        ----------
+        state : User
+            State of disconnected user.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_userDisconnected.invokeAsync(self, ((state, ), context))
+
+    def userStateChanged(self, state: User, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a user state changes. This is called if the user moves, is renamed, is muted, deafened etc.
+        
+        Parameters
+        ----------
+        state : User
+            New state of user.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_userStateChanged.invoke(self, ((state, ), context))
+
+    def userStateChangedAsync(self, state: User, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a user state changes. This is called if the user moves, is renamed, is muted, deafened etc.
+        
+        Parameters
+        ----------
+        state : User
+            New state of user.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_userStateChanged.invokeAsync(self, ((state, ), context))
+
+    def userTextMessage(self, state: User, message: TextMessage, context: dict[str, str] | None = None) -> None:
+        """
+        Called when user writes a text message
+        
+        Parameters
+        ----------
+        state : User
+            the User sending the message
+        message : TextMessage
+            the TextMessage the user has sent
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_userTextMessage.invoke(self, ((state, message), context))
+
+    def userTextMessageAsync(self, state: User, message: TextMessage, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when user writes a text message
+        
+        Parameters
+        ----------
+        state : User
+            the User sending the message
+        message : TextMessage
+            the TextMessage the user has sent
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_userTextMessage.invokeAsync(self, ((state, message), context))
+
+    def channelCreated(self, state: Channel, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a new channel is created.
+        
+        Parameters
+        ----------
+        state : Channel
+            State of new channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_channelCreated.invoke(self, ((state, ), context))
+
+    def channelCreatedAsync(self, state: Channel, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a new channel is created.
+        
+        Parameters
+        ----------
+        state : Channel
+            State of new channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_channelCreated.invokeAsync(self, ((state, ), context))
+
+    def channelRemoved(self, state: Channel, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a channel is removed. The channel has already been removed, you can no longer use methods like ``Server.getChannelState``
+        
+        Parameters
+        ----------
+        state : Channel
+            State of removed channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_channelRemoved.invoke(self, ((state, ), context))
+
+    def channelRemovedAsync(self, state: Channel, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a channel is removed. The channel has already been removed, you can no longer use methods like ``Server.getChannelState``
+        
+        Parameters
+        ----------
+        state : Channel
+            State of removed channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_channelRemoved.invokeAsync(self, ((state, ), context))
+
+    def channelStateChanged(self, state: Channel, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a new channel state changes. This is called if the channel is moved, renamed or if new links are added.
+        
+        Parameters
+        ----------
+        state : Channel
+            New state of channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerCallback._op_channelStateChanged.invoke(self, ((state, ), context))
+
+    def channelStateChangedAsync(self, state: Channel, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a new channel state changes. This is called if the channel is moved, renamed or if new links are added.
+        
+        Parameters
+        ----------
+        state : Channel
+            New state of channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerCallback._op_channelStateChanged.invokeAsync(self, ((state, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ServerCallbackPrx | None:
+        return checkedCast(ServerCallbackPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ServerCallbackPrx | None ]:
+        return checkedCastAsync(ServerCallbackPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ServerCallbackPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ServerCallbackPrx | None:
+        return uncheckedCast(ServerCallbackPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerCallback"
+
+IcePy.defineProxy("::MumbleServer::ServerCallback", ServerCallbackPrx)
+
+class ServerCallback(Object, ABC):
+    """
+    Callback interface for servers. You can supply an implementation of this to receive notification
+    messages from the server.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    Note that callbacks are removed when a server is stopped, so you should have a callback for
+    ``MetaCallback.started`` which calls ``Server.addCallback``.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::ServerCallback``.
+    
+    See Also
+    --------
+        :class:`MumbleServer.MetaCallbackPrx`
+        ``Server.addCallback``
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::ServerCallback", )
+    _op_userConnected: IcePy.Operation
+    _op_userDisconnected: IcePy.Operation
+    _op_userStateChanged: IcePy.Operation
+    _op_userTextMessage: IcePy.Operation
+    _op_channelCreated: IcePy.Operation
+    _op_channelRemoved: IcePy.Operation
+    _op_channelStateChanged: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerCallback"
+
+    @abstractmethod
+    def userConnected(self, state: User, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a user connects to the server.
+        
+        Parameters
+        ----------
+        state : User
+            State of connected user.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def userDisconnected(self, state: User, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a user disconnects from the server. The user has already been removed, so you can no longer use methods like ``Server.getState``
+        to retrieve the user's state.
+        
+        Parameters
+        ----------
+        state : User
+            State of disconnected user.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def userStateChanged(self, state: User, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a user state changes. This is called if the user moves, is renamed, is muted, deafened etc.
+        
+        Parameters
+        ----------
+        state : User
+            New state of user.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def userTextMessage(self, state: User, message: TextMessage, current: Current) -> None | Awaitable[None]:
+        """
+        Called when user writes a text message
+        
+        Parameters
+        ----------
+        state : User
+            the User sending the message
+        message : TextMessage
+            the TextMessage the user has sent
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def channelCreated(self, state: Channel, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a new channel is created.
+        
+        Parameters
+        ----------
+        state : Channel
+            State of new channel.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def channelRemoved(self, state: Channel, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a channel is removed. The channel has already been removed, you can no longer use methods like ``Server.getChannelState``
+        
+        Parameters
+        ----------
+        state : Channel
+            State of removed channel.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def channelStateChanged(self, state: Channel, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a new channel state changes. This is called if the channel is moved, renamed or if new links are added.
+        
+        Parameters
+        ----------
+        state : Channel
+            New state of channel.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+ServerCallback._op_userConnected = IcePy.Operation(
+    "userConnected",
+    "userConnected",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_User_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServerCallback._op_userDisconnected = IcePy.Operation(
+    "userDisconnected",
+    "userDisconnected",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_User_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServerCallback._op_userStateChanged = IcePy.Operation(
+    "userStateChanged",
+    "userStateChanged",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_User_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServerCallback._op_userTextMessage = IcePy.Operation(
+    "userTextMessage",
+    "userTextMessage",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_User_t, False, 0), ((), _MumbleServer_TextMessage_t, False, 0)),
+    (),
+    None,
+    ())
+
+ServerCallback._op_channelCreated = IcePy.Operation(
+    "channelCreated",
+    "channelCreated",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_Channel_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServerCallback._op_channelRemoved = IcePy.Operation(
+    "channelRemoved",
+    "channelRemoved",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_Channel_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServerCallback._op_channelStateChanged = IcePy.Operation(
+    "channelStateChanged",
+    "channelStateChanged",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _MumbleServer_Channel_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["ServerCallback", "ServerCallbackPrx", "_MumbleServer_ServerCallbackPrx_t"]

MumbleServer/ServerCallback_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ServerCallbackPrx_t = IcePy.declareProxy("::MumbleServer::ServerCallback")
+
+__all__ = ["_MumbleServer_ServerCallbackPrx_t"]

MumbleServer/ServerContextCallback.py

@@ -0,0 +1,180 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.ServerContextCallback_forward import _MumbleServer_ServerContextCallbackPrx_t
+
+from MumbleServer.User import _MumbleServer_User_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from MumbleServer.User import User
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class ServerContextCallbackPrx(ObjectPrx):
+    """
+    Callback interface for context actions. You need to supply one of these for ``Server.addContext``.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::ServerContextCallback``.
+    """
+
+    def contextAction(self, action: str, usr: User, session: int, channelid: int, context: dict[str, str] | None = None) -> None:
+        """
+        Called when a context action is performed.
+        
+        Parameters
+        ----------
+        action : str
+            Action to be performed.
+        usr : User
+            User which initiated the action.
+        session : int
+            If nonzero, session of target user.
+        channelid : int
+            If not -1, id of target channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServerContextCallback._op_contextAction.invoke(self, ((action, usr, session, channelid), context))
+
+    def contextActionAsync(self, action: str, usr: User, session: int, channelid: int, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Called when a context action is performed.
+        
+        Parameters
+        ----------
+        action : str
+            Action to be performed.
+        usr : User
+            User which initiated the action.
+        session : int
+            If nonzero, session of target user.
+        channelid : int
+            If not -1, id of target channel.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServerContextCallback._op_contextAction.invokeAsync(self, ((action, usr, session, channelid), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ServerContextCallbackPrx | None:
+        return checkedCast(ServerContextCallbackPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ServerContextCallbackPrx | None ]:
+        return checkedCastAsync(ServerContextCallbackPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ServerContextCallbackPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ServerContextCallbackPrx | None:
+        return uncheckedCast(ServerContextCallbackPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerContextCallback"
+
+IcePy.defineProxy("::MumbleServer::ServerContextCallback", ServerContextCallbackPrx)
+
+class ServerContextCallback(Object, ABC):
+    """
+    Callback interface for context actions. You need to supply one of these for ``Server.addContext``.
+    If an added callback ever throws an exception or goes away, it will be automatically removed.
+    Please note that all callbacks are done asynchronously; the server does not wait for the callback to
+    complete before continuing processing.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::ServerContextCallback``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::ServerContextCallback", )
+    _op_contextAction: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerContextCallback"
+
+    @abstractmethod
+    def contextAction(self, action: str, usr: User, session: int, channelid: int, current: Current) -> None | Awaitable[None]:
+        """
+        Called when a context action is performed.
+        
+        Parameters
+        ----------
+        action : str
+            Action to be performed.
+        usr : User
+            User which initiated the action.
+        session : int
+            If nonzero, session of target user.
+        channelid : int
+            If not -1, id of target channel.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+ServerContextCallback._op_contextAction = IcePy.Operation(
+    "contextAction",
+    "contextAction",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _MumbleServer_User_t, False, 0), ((), IcePy._t_int, False, 0), ((), IcePy._t_int, False, 0)),
+    (),
+    None,
+    ())
+
+__all__ = ["ServerContextCallback", "ServerContextCallbackPrx", "_MumbleServer_ServerContextCallbackPrx_t"]

MumbleServer/ServerContextCallback_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ServerContextCallbackPrx_t = IcePy.declareProxy("::MumbleServer::ServerContextCallback")
+
+__all__ = ["_MumbleServer_ServerContextCallbackPrx_t"]

MumbleServer/ServerException.py

@@ -0,0 +1,32 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.UserException import UserException
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ServerException(UserException):
+    """
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::ServerException``.
+    """
+
+    _ice_id = "::MumbleServer::ServerException"
+
+_MumbleServer_ServerException_t = IcePy.defineException(
+    "::MumbleServer::ServerException",
+    ServerException,
+    (),
+    None,
+    ())
+
+setattr(ServerException, '_ice_type', _MumbleServer_ServerException_t)
+
+__all__ = ["ServerException", "_MumbleServer_ServerException_t"]

MumbleServer/ServerFailureException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ServerFailureException(ServerException):
+    """
+    This is thrown if ``Server.start`` fails, and should generally be the cause for some concern.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::ServerFailureException``.
+    """
+
+    _ice_id = "::MumbleServer::ServerFailureException"
+
+_MumbleServer_ServerFailureException_t = IcePy.defineException(
+    "::MumbleServer::ServerFailureException",
+    ServerFailureException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(ServerFailureException, '_ice_type', _MumbleServer_ServerFailureException_t)
+
+__all__ = ["ServerFailureException", "_MumbleServer_ServerFailureException_t"]

MumbleServer/ServerList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Server_forward import _MumbleServer_ServerPrx_t
+
+_MumbleServer_ServerList_t = IcePy.defineSequence("::MumbleServer::ServerList", (), _MumbleServer_ServerPrx_t)
+
+__all__ = ["_MumbleServer_ServerList_t"]

MumbleServer/ServerUpdatingAuthenticator.py

@@ -0,0 +1,462 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from MumbleServer.CertificateList import _MumbleServer_CertificateList_t
+
+from MumbleServer.GroupNameList import _MumbleServer_GroupNameList_t
+
+from MumbleServer.NameMap import _MumbleServer_NameMap_t
+
+from MumbleServer.ServerAuthenticator import ServerAuthenticator
+from MumbleServer.ServerAuthenticator import ServerAuthenticatorPrx
+
+from MumbleServer.ServerUpdatingAuthenticator_forward import _MumbleServer_ServerUpdatingAuthenticatorPrx_t
+
+from MumbleServer.Texture import _MumbleServer_Texture_t
+
+from MumbleServer.UserInfoMap import _MumbleServer_UserInfoMap_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from Ice.ObjectPrx import ObjectPrx
+    from MumbleServer.UserInfo import UserInfo
+    from collections.abc import Awaitable
+    from collections.abc import Buffer
+    from collections.abc import Mapping
+    from collections.abc import Sequence
+
+
+class ServerUpdatingAuthenticatorPrx(ServerAuthenticatorPrx):
+    """
+    Callback interface for server authentication and registration. This allows you to support both authentication
+    and account updating.
+    You do not need to implement this if all you want is authentication, you only need this if other scripts
+    connected to the same server calls e.g. ``Server.setTexture``.
+    Almost all of these methods support fall through, meaning the server should continue the operation against its
+    own database.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::ServerUpdatingAuthenticator``.
+    """
+
+    def registerUser(self, info: Mapping[UserInfo, str], context: dict[str, str] | None = None) -> int:
+        """
+        Register a new user.
+        
+        Parameters
+        ----------
+        info : Mapping[UserInfo, str]
+            Information about user to register.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            User id of new user, -1 for registration failure, or -2 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_registerUser.invoke(self, ((info, ), context))
+
+    def registerUserAsync(self, info: Mapping[UserInfo, str], context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Register a new user.
+        
+        Parameters
+        ----------
+        info : Mapping[UserInfo, str]
+            Information about user to register.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            User id of new user, -1 for registration failure, or -2 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_registerUser.invokeAsync(self, ((info, ), context))
+
+    def unregisterUser(self, id: int, context: dict[str, str] | None = None) -> int:
+        """
+        Unregister a user.
+        
+        Parameters
+        ----------
+        id : int
+            Userid to unregister.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            1 for successful unregistration, 0 for unsuccessful unregistration, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_unregisterUser.invoke(self, ((id, ), context))
+
+    def unregisterUserAsync(self, id: int, context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Unregister a user.
+        
+        Parameters
+        ----------
+        id : int
+            Userid to unregister.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            1 for successful unregistration, 0 for unsuccessful unregistration, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_unregisterUser.invokeAsync(self, ((id, ), context))
+
+    def getRegisteredUsers(self, filter: str, context: dict[str, str] | None = None) -> dict[int, str]:
+        """
+        Get a list of registered users matching filter.
+        
+        Parameters
+        ----------
+        filter : str
+            Substring usernames must contain. If empty, return all registered users.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        dict[int, str]
+            List of matching registered users.
+        """
+        return ServerUpdatingAuthenticator._op_getRegisteredUsers.invoke(self, ((filter, ), context))
+
+    def getRegisteredUsersAsync(self, filter: str, context: dict[str, str] | None = None) -> Awaitable[dict[int, str]]:
+        """
+        Get a list of registered users matching filter.
+        
+        Parameters
+        ----------
+        filter : str
+            Substring usernames must contain. If empty, return all registered users.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[dict[int, str]]
+            List of matching registered users.
+        """
+        return ServerUpdatingAuthenticator._op_getRegisteredUsers.invokeAsync(self, ((filter, ), context))
+
+    def setInfo(self, id: int, info: Mapping[UserInfo, str], context: dict[str, str] | None = None) -> int:
+        """
+        Set additional information for user registration.
+        
+        Parameters
+        ----------
+        id : int
+            Userid of registered user.
+        info : Mapping[UserInfo, str]
+            Information to set about user. This should be merged with existing information.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_setInfo.invoke(self, ((id, info), context))
+
+    def setInfoAsync(self, id: int, info: Mapping[UserInfo, str], context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Set additional information for user registration.
+        
+        Parameters
+        ----------
+        id : int
+            Userid of registered user.
+        info : Mapping[UserInfo, str]
+            Information to set about user. This should be merged with existing information.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_setInfo.invokeAsync(self, ((id, info), context))
+
+    def setTexture(self, id: int, tex: Sequence[int] | bytes | Buffer, context: dict[str, str] | None = None) -> int:
+        """
+        Set texture (now called avatar) of user registration.
+        
+        Parameters
+        ----------
+        id : int
+            registrationId of registered user.
+        tex : Sequence[int] | bytes | Buffer
+            New texture.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_setTexture.invoke(self, ((id, tex), context))
+
+    def setTextureAsync(self, id: int, tex: Sequence[int] | bytes | Buffer, context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Set texture (now called avatar) of user registration.
+        
+        Parameters
+        ----------
+        id : int
+            registrationId of registered user.
+        tex : Sequence[int] | bytes | Buffer
+            New texture.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        return ServerUpdatingAuthenticator._op_setTexture.invokeAsync(self, ((id, tex), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ServerUpdatingAuthenticatorPrx | None:
+        return checkedCast(ServerUpdatingAuthenticatorPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ServerUpdatingAuthenticatorPrx | None ]:
+        return checkedCastAsync(ServerUpdatingAuthenticatorPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ServerUpdatingAuthenticatorPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ServerUpdatingAuthenticatorPrx | None:
+        return uncheckedCast(ServerUpdatingAuthenticatorPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerUpdatingAuthenticator"
+
+IcePy.defineProxy("::MumbleServer::ServerUpdatingAuthenticator", ServerUpdatingAuthenticatorPrx)
+
+class ServerUpdatingAuthenticator(ServerAuthenticator, ABC):
+    """
+    Callback interface for server authentication and registration. This allows you to support both authentication
+    and account updating.
+    You do not need to implement this if all you want is authentication, you only need this if other scripts
+    connected to the same server calls e.g. ``Server.setTexture``.
+    Almost all of these methods support fall through, meaning the server should continue the operation against its
+    own database.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::ServerUpdatingAuthenticator``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::ServerAuthenticator", "::MumbleServer::ServerUpdatingAuthenticator", )
+    _op_registerUser: IcePy.Operation
+    _op_unregisterUser: IcePy.Operation
+    _op_getRegisteredUsers: IcePy.Operation
+    _op_setInfo: IcePy.Operation
+    _op_setTexture: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::ServerUpdatingAuthenticator"
+
+    @abstractmethod
+    def registerUser(self, info: dict[UserInfo, str], current: Current) -> int | Awaitable[int]:
+        """
+        Register a new user.
+        
+        Parameters
+        ----------
+        info : dict[UserInfo, str]
+            Information about user to register.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            User id of new user, -1 for registration failure, or -2 to fall through.
+        """
+        pass
+
+    @abstractmethod
+    def unregisterUser(self, id: int, current: Current) -> int | Awaitable[int]:
+        """
+        Unregister a user.
+        
+        Parameters
+        ----------
+        id : int
+            Userid to unregister.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            1 for successful unregistration, 0 for unsuccessful unregistration, -1 to fall through.
+        """
+        pass
+
+    @abstractmethod
+    def getRegisteredUsers(self, filter: str, current: Current) -> Mapping[int, str] | Awaitable[Mapping[int, str]]:
+        """
+        Get a list of registered users matching filter.
+        
+        Parameters
+        ----------
+        filter : str
+            Substring usernames must contain. If empty, return all registered users.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Mapping[int, str] | Awaitable[Mapping[int, str]]
+            List of matching registered users.
+        """
+        pass
+
+    @abstractmethod
+    def setInfo(self, id: int, info: dict[UserInfo, str], current: Current) -> int | Awaitable[int]:
+        """
+        Set additional information for user registration.
+        
+        Parameters
+        ----------
+        id : int
+            Userid of registered user.
+        info : dict[UserInfo, str]
+            Information to set about user. This should be merged with existing information.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        pass
+
+    @abstractmethod
+    def setTexture(self, id: int, tex: bytes, current: Current) -> int | Awaitable[int]:
+        """
+        Set texture (now called avatar) of user registration.
+        
+        Parameters
+        ----------
+        id : int
+            registrationId of registered user.
+        tex : bytes
+            New texture.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            1 for successful update, 0 for unsuccessful update, -1 to fall through.
+        """
+        pass
+
+ServerUpdatingAuthenticator._op_registerUser = IcePy.Operation(
+    "registerUser",
+    "registerUser",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _MumbleServer_UserInfoMap_t, False, 0),),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+ServerUpdatingAuthenticator._op_unregisterUser = IcePy.Operation(
+    "unregisterUser",
+    "unregisterUser",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+ServerUpdatingAuthenticator._op_getRegisteredUsers = IcePy.Operation(
+    "getRegisteredUsers",
+    "getRegisteredUsers",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    ((), _MumbleServer_NameMap_t, False, 0),
+    ())
+
+ServerUpdatingAuthenticator._op_setInfo = IcePy.Operation(
+    "setInfo",
+    "setInfo",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), _MumbleServer_UserInfoMap_t, False, 0)),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+ServerUpdatingAuthenticator._op_setTexture = IcePy.Operation(
+    "setTexture",
+    "setTexture",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), _MumbleServer_Texture_t, False, 0)),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+__all__ = ["ServerUpdatingAuthenticator", "ServerUpdatingAuthenticatorPrx", "_MumbleServer_ServerUpdatingAuthenticatorPrx_t"]

MumbleServer/ServerUpdatingAuthenticator_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ServerUpdatingAuthenticatorPrx_t = IcePy.declareProxy("::MumbleServer::ServerUpdatingAuthenticator")
+
+__all__ = ["_MumbleServer_ServerUpdatingAuthenticatorPrx_t"]

MumbleServer/Server_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_ServerPrx_t = IcePy.declareProxy("::MumbleServer::Server")
+
+__all__ = ["_MumbleServer_ServerPrx_t"]

MumbleServer/TextMessage.py

@@ -0,0 +1,55 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.IntList import _MumbleServer_IntList_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Buffer
+
+
+@dataclass
+class TextMessage:
+    """
+    A text message between users.
+    
+    Attributes
+    ----------
+    sessions : list[int]
+        Sessions (connected users) who were sent this message.
+    channels : list[int]
+        Channels who were sent this message.
+    trees : list[int]
+        Trees of channels who were sent this message.
+    text : str
+        The contents of the message.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::TextMessage``.
+    """
+    sessions: list[int] = field(default_factory=list)
+    channels: list[int] = field(default_factory=list)
+    trees: list[int] = field(default_factory=list)
+    text: str = ""
+
+_MumbleServer_TextMessage_t = IcePy.defineStruct(
+    "::MumbleServer::TextMessage",
+    TextMessage,
+    (),
+    (
+        ("sessions", (), _MumbleServer_IntList_t),
+        ("channels", (), _MumbleServer_IntList_t),
+        ("trees", (), _MumbleServer_IntList_t),
+        ("text", (), IcePy._t_string)
+    ))
+
+__all__ = ["TextMessage", "_MumbleServer_TextMessage_t"]

MumbleServer/Texture.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_Texture_t = IcePy.defineSequence("::MumbleServer::Texture", (), IcePy._t_byte)
+
+__all__ = ["_MumbleServer_Texture_t"]

MumbleServer/Tree.py

@@ -0,0 +1,68 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Value import Value
+
+from MumbleServer.Channel import Channel
+from MumbleServer.Channel import _MumbleServer_Channel_t
+
+from MumbleServer.TreeList import _MumbleServer_TreeList_t
+
+from MumbleServer.Tree_forward import _MumbleServer_Tree_t
+
+from MumbleServer.UserList import _MumbleServer_UserList_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from MumbleServer.User import User
+
+@dataclass(eq=False)
+class Tree(Value):
+    """
+    User and subchannel state. Read-only.
+    
+    Attributes
+    ----------
+    c : Channel
+        Channel definition of current channel.
+    children : list[Tree | None]
+        List of subchannels.
+    users : list[User]
+        Users in this channel.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::MumbleServer::Tree``.
+    """
+    c: Channel = field(default_factory=Channel)
+    children: list[Tree | None] = field(default_factory=list)
+    users: list[User] = field(default_factory=list)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::MumbleServer::Tree"
+
+_MumbleServer_Tree_t = IcePy.defineValue(
+    "::MumbleServer::Tree",
+    Tree,
+    -1,
+    (),
+    False,
+    None,
+    (
+        ("c", (), _MumbleServer_Channel_t, False, 0),
+        ("children", (), _MumbleServer_TreeList_t, False, 0),
+        ("users", (), _MumbleServer_UserList_t, False, 0)
+    ))
+
+setattr(Tree, '_ice_type', _MumbleServer_Tree_t)
+
+__all__ = ["Tree", "_MumbleServer_Tree_t"]

MumbleServer/TreeList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.Tree_forward import _MumbleServer_Tree_t
+
+_MumbleServer_TreeList_t = IcePy.defineSequence("::MumbleServer::TreeList", (), _MumbleServer_Tree_t)
+
+__all__ = ["_MumbleServer_TreeList_t"]

MumbleServer/Tree_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+_MumbleServer_Tree_t = IcePy.declareValue("::MumbleServer::Tree")
+
+__all__ = ["_MumbleServer_Tree_t"]

MumbleServer/User.py

@@ -0,0 +1,153 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.NetAddress import _MumbleServer_NetAddress_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Buffer
+
+
+@dataclass
+class User:
+    """
+    A connected user.
+    
+    Attributes
+    ----------
+    session : int
+        Session ID. This identifies the connection to the server.
+    userid : int
+        User ID. -1 if the user is anonymous.
+    mute : bool
+        Is user muted by the server?
+    deaf : bool
+        Is user deafened by the server? If true, this implies mute.
+    suppress : bool
+        Is the user suppressed by the server? This means the user is not muted, but does not have speech privileges in the current channel.
+    prioritySpeaker : bool
+        Is the user a priority speaker?
+    selfMute : bool
+        Is the user self-muted?
+    selfDeaf : bool
+        Is the user self-deafened? If true, this implies mute.
+    recording : bool
+        Is the User recording? (This flag is read-only and cannot be changed using setState().)
+    channel : int
+        Channel ID the user is in. Matches ``Channel.id``.
+    name : str
+        The name of the user.
+    onlinesecs : int
+        Seconds user has been online.
+    bytespersec : int
+        Average transmission rate in bytes per second over the last few seconds.
+    version : int
+        Legacy client version.
+    version2 : int
+        New client version. (See https://github.com/mumble-voip/mumble/issues/5827)
+    release : str
+        Client release. For official releases, this equals the version. For snapshots and git compiles, this will be something else.
+    os : str
+        Client OS.
+    osversion : str
+        Client OS Version.
+    identity : str
+        Plugin Identity. This will be the user's unique ID inside the current game.
+    context : str
+        Base64-encoded Plugin context. This is a binary blob identifying the game and team the user is on.
+        
+        The used Base64 alphabet is the one specified in RFC 2045.
+        
+        Before Mumble 1.3.0, this string was not Base64-encoded. This could cause problems for some Ice
+        implementations, such as the .NET implementation.
+        
+        If you need the exact string that is used by Mumble, you can get it by Base64-decoding this string.
+        
+        If you simply need to detect whether two users are in the same game world, string comparisons will
+        continue to work as before.
+    comment : str
+        User comment. Shown as tooltip for this user.
+    address : bytes
+        Client address.
+    tcponly : bool
+        TCP only. True until UDP connectivity is established.
+    idlesecs : int
+        Idle time. This is how many seconds it is since the user last spoke. Other activity is not counted.
+    udpPing : float
+        UDP Ping Average. This is the average ping for the user via UDP over the duration of the connection.
+    tcpPing : float
+        TCP Ping Average. This is the average ping for the user via TCP over the duration of the connection.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::MumbleServer::User``.
+    """
+    session: int = 0
+    userid: int = 0
+    mute: bool = False
+    deaf: bool = False
+    suppress: bool = False
+    prioritySpeaker: bool = False
+    selfMute: bool = False
+    selfDeaf: bool = False
+    recording: bool = False
+    channel: int = 0
+    name: str = ""
+    onlinesecs: int = 0
+    bytespersec: int = 0
+    version: int = 0
+    version2: int = 0
+    release: str = ""
+    os: str = ""
+    osversion: str = ""
+    identity: str = ""
+    context: str = ""
+    comment: str = ""
+    address: bytes = field(default_factory=bytes)
+    tcponly: bool = False
+    idlesecs: int = 0
+    udpPing: float = 0.0
+    tcpPing: float = 0.0
+
+_MumbleServer_User_t = IcePy.defineStruct(
+    "::MumbleServer::User",
+    User,
+    (),
+    (
+        ("session", (), IcePy._t_int),
+        ("userid", (), IcePy._t_int),
+        ("mute", (), IcePy._t_bool),
+        ("deaf", (), IcePy._t_bool),
+        ("suppress", (), IcePy._t_bool),
+        ("prioritySpeaker", (), IcePy._t_bool),
+        ("selfMute", (), IcePy._t_bool),
+        ("selfDeaf", (), IcePy._t_bool),
+        ("recording", (), IcePy._t_bool),
+        ("channel", (), IcePy._t_int),
+        ("name", (), IcePy._t_string),
+        ("onlinesecs", (), IcePy._t_int),
+        ("bytespersec", (), IcePy._t_int),
+        ("version", (), IcePy._t_int),
+        ("version2", (), IcePy._t_long),
+        ("release", (), IcePy._t_string),
+        ("os", (), IcePy._t_string),
+        ("osversion", (), IcePy._t_string),
+        ("identity", (), IcePy._t_string),
+        ("context", (), IcePy._t_string),
+        ("comment", (), IcePy._t_string),
+        ("address", (), _MumbleServer_NetAddress_t),
+        ("tcponly", (), IcePy._t_bool),
+        ("idlesecs", (), IcePy._t_int),
+        ("udpPing", (), IcePy._t_float),
+        ("tcpPing", (), IcePy._t_float)
+    ))
+
+__all__ = ["User", "_MumbleServer_User_t"]

MumbleServer/UserInfo.py

@@ -0,0 +1,46 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class UserInfo(Enum):
+    """
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::MumbleServer::UserInfo``.
+    """
+
+    UserName = 0
+
+    UserEmail = 1
+
+    UserComment = 2
+
+    UserHash = 3
+
+    UserPassword = 4
+
+    UserLastActive = 5
+
+    UserKDFIterations = 6
+
+_MumbleServer_UserInfo_t = IcePy.defineEnum(
+    "::MumbleServer::UserInfo",
+    UserInfo,
+    (),
+    {
+        0: UserInfo.UserName,
+        1: UserInfo.UserEmail,
+        2: UserInfo.UserComment,
+        3: UserInfo.UserHash,
+        4: UserInfo.UserPassword,
+        5: UserInfo.UserLastActive,
+        6: UserInfo.UserKDFIterations,
+    }
+)
+
+__all__ = ["UserInfo", "_MumbleServer_UserInfo_t"]

MumbleServer/UserInfoMap.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.UserInfo import _MumbleServer_UserInfo_t
+
+_MumbleServer_UserInfoMap_t = IcePy.defineDictionary("::MumbleServer::UserInfoMap", (), _MumbleServer_UserInfo_t, IcePy._t_string)
+
+__all__ = ["_MumbleServer_UserInfoMap_t"]

MumbleServer/UserList.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.User import _MumbleServer_User_t
+
+_MumbleServer_UserList_t = IcePy.defineSequence("::MumbleServer::UserList", (), _MumbleServer_User_t)
+
+__all__ = ["_MumbleServer_UserList_t"]

MumbleServer/UserMap.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.User import _MumbleServer_User_t
+
+_MumbleServer_UserMap_t = IcePy.defineDictionary("::MumbleServer::UserMap", (), IcePy._t_int, _MumbleServer_User_t)
+
+__all__ = ["_MumbleServer_UserMap_t"]

MumbleServer/WriteOnlyException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from __future__ import annotations
+import IcePy
+
+from MumbleServer.ServerException import ServerException
+from MumbleServer.ServerException import _MumbleServer_ServerException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class WriteOnlyException(ServerException):
+    """
+    This is thrown when you ask the server to disclose something that should be secret.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::MumbleServer::WriteOnlyException``.
+    """
+
+    _ice_id = "::MumbleServer::WriteOnlyException"
+
+_MumbleServer_WriteOnlyException_t = IcePy.defineException(
+    "::MumbleServer::WriteOnlyException",
+    WriteOnlyException,
+    (),
+    _MumbleServer_ServerException_t,
+    ())
+
+setattr(WriteOnlyException, '_ice_type', _MumbleServer_WriteOnlyException_t)
+
+__all__ = ["WriteOnlyException", "_MumbleServer_WriteOnlyException_t"]

MumbleServer/__init__.py

@@ -0,0 +1,241 @@
+
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.1
+
+from .ACL import ACL
+from .ACL import _MumbleServer_ACL_t
+from .ACLList import _MumbleServer_ACLList_t
+from .Ban import Ban
+from .Ban import _MumbleServer_Ban_t
+from .BanList import _MumbleServer_BanList_t
+from .CertificateDer import _MumbleServer_CertificateDer_t
+from .CertificateList import _MumbleServer_CertificateList_t
+from .Channel import Channel
+from .Channel import _MumbleServer_Channel_t
+from .ChannelInfo import ChannelInfo
+from .ChannelInfo import _MumbleServer_ChannelInfo_t
+from .ChannelList import _MumbleServer_ChannelList_t
+from .ChannelMap import _MumbleServer_ChannelMap_t
+from .ConfigMap import _MumbleServer_ConfigMap_t
+from .ContextChannel import ContextChannel
+from .ContextServer import ContextServer
+from .ContextUser import ContextUser
+from .DBState import DBState
+from .DBState import _MumbleServer_DBState_t
+from .Group import Group
+from .Group import _MumbleServer_Group_t
+from .GroupList import _MumbleServer_GroupList_t
+from .GroupNameList import _MumbleServer_GroupNameList_t
+from .IdList import _MumbleServer_IdList_t
+from .IdMap import _MumbleServer_IdMap_t
+from .IntList import _MumbleServer_IntList_t
+from .InternalErrorException import InternalErrorException
+from .InternalErrorException import _MumbleServer_InternalErrorException_t
+from .InvalidCallbackException import InvalidCallbackException
+from .InvalidCallbackException import _MumbleServer_InvalidCallbackException_t
+from .InvalidChannelException import InvalidChannelException
+from .InvalidChannelException import _MumbleServer_InvalidChannelException_t
+from .InvalidInputDataException import InvalidInputDataException
+from .InvalidInputDataException import _MumbleServer_InvalidInputDataException_t
+from .InvalidListenerException import InvalidListenerException
+from .InvalidListenerException import _MumbleServer_InvalidListenerException_t
+from .InvalidSecretException import InvalidSecretException
+from .InvalidSecretException import _MumbleServer_InvalidSecretException_t
+from .InvalidServerException import InvalidServerException
+from .InvalidServerException import _MumbleServer_InvalidServerException_t
+from .InvalidSessionException import InvalidSessionException
+from .InvalidSessionException import _MumbleServer_InvalidSessionException_t
+from .InvalidTextureException import InvalidTextureException
+from .InvalidTextureException import _MumbleServer_InvalidTextureException_t
+from .InvalidUserException import InvalidUserException
+from .InvalidUserException import _MumbleServer_InvalidUserException_t
+from .LogEntry import LogEntry
+from .LogEntry import _MumbleServer_LogEntry_t
+from .LogList import _MumbleServer_LogList_t
+from .Meta import Meta
+from .Meta import MetaPrx
+from .MetaCallback import MetaCallback
+from .MetaCallback import MetaCallbackPrx
+from .MetaCallback_forward import _MumbleServer_MetaCallbackPrx_t
+from .Meta_forward import _MumbleServer_MetaPrx_t
+from .NameList import _MumbleServer_NameList_t
+from .NameMap import _MumbleServer_NameMap_t
+from .NestingLimitException import NestingLimitException
+from .NestingLimitException import _MumbleServer_NestingLimitException_t
+from .NetAddress import _MumbleServer_NetAddress_t
+from .PermissionBan import PermissionBan
+from .PermissionEnter import PermissionEnter
+from .PermissionKick import PermissionKick
+from .PermissionLinkChannel import PermissionLinkChannel
+from .PermissionMakeChannel import PermissionMakeChannel
+from .PermissionMakeTempChannel import PermissionMakeTempChannel
+from .PermissionMove import PermissionMove
+from .PermissionMuteDeafen import PermissionMuteDeafen
+from .PermissionRegister import PermissionRegister
+from .PermissionRegisterSelf import PermissionRegisterSelf
+from .PermissionSpeak import PermissionSpeak
+from .PermissionTextMessage import PermissionTextMessage
+from .PermissionTraverse import PermissionTraverse
+from .PermissionWhisper import PermissionWhisper
+from .PermissionWrite import PermissionWrite
+from .ReadOnlyModeException import ReadOnlyModeException
+from .ReadOnlyModeException import _MumbleServer_ReadOnlyModeException_t
+from .ResetUserContent import ResetUserContent
+from .Server import Server
+from .Server import ServerPrx
+from .ServerAuthenticator import ServerAuthenticator
+from .ServerAuthenticator import ServerAuthenticatorPrx
+from .ServerAuthenticator_forward import _MumbleServer_ServerAuthenticatorPrx_t
+from .ServerBootedException import ServerBootedException
+from .ServerBootedException import _MumbleServer_ServerBootedException_t
+from .ServerCallback import ServerCallback
+from .ServerCallback import ServerCallbackPrx
+from .ServerCallback_forward import _MumbleServer_ServerCallbackPrx_t
+from .ServerContextCallback import ServerContextCallback
+from .ServerContextCallback import ServerContextCallbackPrx
+from .ServerContextCallback_forward import _MumbleServer_ServerContextCallbackPrx_t
+from .ServerException import ServerException
+from .ServerException import _MumbleServer_ServerException_t
+from .ServerFailureException import ServerFailureException
+from .ServerFailureException import _MumbleServer_ServerFailureException_t
+from .ServerList import _MumbleServer_ServerList_t
+from .ServerUpdatingAuthenticator import ServerUpdatingAuthenticator
+from .ServerUpdatingAuthenticator import ServerUpdatingAuthenticatorPrx
+from .ServerUpdatingAuthenticator_forward import _MumbleServer_ServerUpdatingAuthenticatorPrx_t
+from .Server_forward import _MumbleServer_ServerPrx_t
+from .TextMessage import TextMessage
+from .TextMessage import _MumbleServer_TextMessage_t
+from .Texture import _MumbleServer_Texture_t
+from .Tree import Tree
+from .TreeList import _MumbleServer_TreeList_t
+from .Tree_forward import _MumbleServer_Tree_t
+from .User import User
+from .User import _MumbleServer_User_t
+from .UserInfo import UserInfo
+from .UserInfo import _MumbleServer_UserInfo_t
+from .UserInfoMap import _MumbleServer_UserInfoMap_t
+from .UserList import _MumbleServer_UserList_t
+from .UserMap import _MumbleServer_UserMap_t
+from .WriteOnlyException import WriteOnlyException
+from .WriteOnlyException import _MumbleServer_WriteOnlyException_t
+
+
+__all__ = [
+    "ACL",
+    "_MumbleServer_ACL_t",
+    "_MumbleServer_ACLList_t",
+    "Ban",
+    "_MumbleServer_Ban_t",
+    "_MumbleServer_BanList_t",
+    "_MumbleServer_CertificateDer_t",
+    "_MumbleServer_CertificateList_t",
+    "Channel",
+    "_MumbleServer_Channel_t",
+    "ChannelInfo",
+    "_MumbleServer_ChannelInfo_t",
+    "_MumbleServer_ChannelList_t",
+    "_MumbleServer_ChannelMap_t",
+    "_MumbleServer_ConfigMap_t",
+    "ContextChannel",
+    "ContextServer",
+    "ContextUser",
+    "DBState",
+    "_MumbleServer_DBState_t",
+    "Group",
+    "_MumbleServer_Group_t",
+    "_MumbleServer_GroupList_t",
+    "_MumbleServer_GroupNameList_t",
+    "_MumbleServer_IdList_t",
+    "_MumbleServer_IdMap_t",
+    "_MumbleServer_IntList_t",
+    "InternalErrorException",
+    "_MumbleServer_InternalErrorException_t",
+    "InvalidCallbackException",
+    "_MumbleServer_InvalidCallbackException_t",
+    "InvalidChannelException",
+    "_MumbleServer_InvalidChannelException_t",
+    "InvalidInputDataException",
+    "_MumbleServer_InvalidInputDataException_t",
+    "InvalidListenerException",
+    "_MumbleServer_InvalidListenerException_t",
+    "InvalidSecretException",
+    "_MumbleServer_InvalidSecretException_t",
+    "InvalidServerException",
+    "_MumbleServer_InvalidServerException_t",
+    "InvalidSessionException",
+    "_MumbleServer_InvalidSessionException_t",
+    "InvalidTextureException",
+    "_MumbleServer_InvalidTextureException_t",
+    "InvalidUserException",
+    "_MumbleServer_InvalidUserException_t",
+    "LogEntry",
+    "_MumbleServer_LogEntry_t",
+    "_MumbleServer_LogList_t",
+    "Meta",
+    "MetaPrx",
+    "MetaCallback",
+    "MetaCallbackPrx",
+    "_MumbleServer_MetaCallbackPrx_t",
+    "_MumbleServer_MetaPrx_t",
+    "_MumbleServer_NameList_t",
+    "_MumbleServer_NameMap_t",
+    "NestingLimitException",
+    "_MumbleServer_NestingLimitException_t",
+    "_MumbleServer_NetAddress_t",
+    "PermissionBan",
+    "PermissionEnter",
+    "PermissionKick",
+    "PermissionLinkChannel",
+    "PermissionMakeChannel",
+    "PermissionMakeTempChannel",
+    "PermissionMove",
+    "PermissionMuteDeafen",
+    "PermissionRegister",
+    "PermissionRegisterSelf",
+    "PermissionSpeak",
+    "PermissionTextMessage",
+    "PermissionTraverse",
+    "PermissionWhisper",
+    "PermissionWrite",
+    "ReadOnlyModeException",
+    "_MumbleServer_ReadOnlyModeException_t",
+    "ResetUserContent",
+    "Server",
+    "ServerPrx",
+    "ServerAuthenticator",
+    "ServerAuthenticatorPrx",
+    "_MumbleServer_ServerAuthenticatorPrx_t",
+    "ServerBootedException",
+    "_MumbleServer_ServerBootedException_t",
+    "ServerCallback",
+    "ServerCallbackPrx",
+    "_MumbleServer_ServerCallbackPrx_t",
+    "ServerContextCallback",
+    "ServerContextCallbackPrx",
+    "_MumbleServer_ServerContextCallbackPrx_t",
+    "ServerException",
+    "_MumbleServer_ServerException_t",
+    "ServerFailureException",
+    "_MumbleServer_ServerFailureException_t",
+    "_MumbleServer_ServerList_t",
+    "ServerUpdatingAuthenticator",
+    "ServerUpdatingAuthenticatorPrx",
+    "_MumbleServer_ServerUpdatingAuthenticatorPrx_t",
+    "_MumbleServer_ServerPrx_t",
+    "TextMessage",
+    "_MumbleServer_TextMessage_t",
+    "_MumbleServer_Texture_t",
+    "Tree",
+    "_MumbleServer_TreeList_t",
+    "_MumbleServer_Tree_t",
+    "User",
+    "_MumbleServer_User_t",
+    "UserInfo",
+    "_MumbleServer_UserInfo_t",
+    "_MumbleServer_UserInfoMap_t",
+    "_MumbleServer_UserList_t",
+    "_MumbleServer_UserMap_t",
+    "WriteOnlyException",
+    "_MumbleServer_WriteOnlyException_t"
+]