├── .gitattributes ├── .github └── workflows │ ├── main.yml │ └── npm.yml ├── .gitignore ├── COMPILING_MURMUR.md ├── LICENSE ├── README.md ├── bin └── matrix-appservice-mumble ├── build.sh ├── gen-bindings.sh ├── lib ├── MurmurRPC.proto ├── MurmurRPC_grpc_pb.d.ts ├── MurmurRPC_grpc_pb.js ├── MurmurRPC_pb.d.ts ├── MurmurRPC_pb.js └── mumble-config-schema.yaml ├── mumble-config.yaml.example ├── package-lock.json ├── package.json ├── src ├── Murmur.ts ├── helpText.ts ├── main.ts └── types.d.ts └── tsconfig.json /.gitattributes: -------------------------------------------------------------------------------- 1 | bin/* linguist-vendored 2 | lib/* linguist-vendored 3 | -------------------------------------------------------------------------------- /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: [push] 4 | 5 | jobs: 6 | build: 7 | 8 | runs-on: ubuntu-latest 9 | 10 | steps: 11 | - uses: actions/checkout@v1 12 | - name: Setup Node.js for use with actions 13 | uses: actions/setup-node@v2.1.4 14 | - name: Build 15 | run: | 16 | npm i 17 | ./build.sh 18 | - name: Upload artifact 19 | uses: actions/upload-artifact@v1.0.0 20 | with: 21 | name: build 22 | path: build 23 | 24 | -------------------------------------------------------------------------------- /.github/workflows/npm.yml: -------------------------------------------------------------------------------- 1 | name: Publish 2 | 3 | on: 4 | release: 5 | types: [published] 6 | 7 | jobs: 8 | build: 9 | runs-on: ubuntu-latest 10 | 11 | steps: 12 | - uses: actions/checkout@v1 13 | - name: Setup Node.js for use with actions 14 | uses: actions/setup-node@v2.1.4 15 | with: 16 | registry-url: 'https://registry.npmjs.org' 17 | - name: Build 18 | run: | 19 | npm i 20 | ./build.sh 21 | - name: Upload artifact 22 | uses: actions/upload-artifact@v1.0.0 23 | with: 24 | name: build 25 | path: build 26 | - name: Publish 27 | run: npm publish 28 | env: 29 | NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }} 30 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | .vscode 3 | mumble-config.yaml 4 | mumble-registration.yaml 5 | room-store.db 6 | user-store.db 7 | build 8 | -------------------------------------------------------------------------------- /COMPILING_MURMUR.md: -------------------------------------------------------------------------------- 1 | # Compiling Murmur With gRPC Support 2 | 3 | ## Compile gRPC and protoc 4 | 5 | Murmur would always segfualt if I used the packaged versions of the gRPC libraries. Make sure you uninstall any packaged versions of gRPC and protobuf before starting. 6 | 7 | 1. [Compile gRPC](https://github.com/grpc/grpc/blob/master/BUILDING.md). 8 | 9 | Make sure to `git checkout` to a relase tag before building. 10 | 11 | 2. After running `make` and `sudo make install` on the main directory, `cd third_party/protobuf` and do another `sudo make install`. 12 | 13 | You might need to add a refrence to the compiled libs in `/etc/ld.so.conf.d` if you didn't set your prefix. Check the output of `make install` for more info. 14 | 15 | pkg-config might not find the grpc `*.pc` files it needs when you compile. You may need to find these files yourself and then run `export PKG_CONFIG_PATH=[dir]`. For me this directory was `/usr/local/lib/pkgconfig`. 16 | 17 | 3. [Compile and install protobuf-c](https://github.com/protobuf-c/protobuf-c#building) to get the `protoc` command. 18 | 19 | Make sure to `git checkout` to a relase tag before building. 20 | 21 | ## Compile Murmur 22 | 23 | 1. Follow the directions [here](https://github.com/mumble-voip/mumble/blob/master/INSTALL). 24 | 25 | 2. Add the flags `grpc` and `no-client`. 26 | 27 | 3. Wait for `make` to finish. 28 | 29 | 4. If successful, Murmur will be in a folder called `release`. 30 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Brendan Early 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # matrix-appservice-mumble 2 | 3 | A Matrix to Mumble bridge. It sends messages between bridged rooms and tells you when people join / leave Murmur. 4 | 5 | ## Installation 6 | 7 | ### These instructions are for a development version, please use the instructions located [here](https://github.com/mymindstorm/matrix-appservice-mumble/tree/0.2.0-install-instructions#matrix-appservice-mumble) 8 | 9 | ### Compiling Murmur with gRPC support 10 | 11 | Murmur is not compiled with gRPC support by default (as of 1.3.0). If you are using Fedora or CentOS, I have a [COPR](https://copr.fedorainfracloud.org/coprs/mymindstorm/mumble-grpc/) that you can use. Otherwise, you will need to compile Murmur yourself. I have some basic notes and directions on compiling Murmur [here](COMPILING_MURMUR.md). 12 | 13 | ### Setup bridge 14 | 15 | 1. Install 16 | 17 | Using npm: 18 | ```bash 19 | npm install --global matrix-appservice-mumble 20 | ``` 21 | 22 | Manually: 23 | 24 | [Download the latest release](https://github.com/mymindstorm/matrix-appservice-mumble/releases) and build 25 | 26 | ```bash 27 | npm i 28 | ./build.sh 29 | ``` 30 | 2. Configure your homeserver 31 | 1. Use `matrix-appservice-mumble` to generate `mumble-registration.yaml` 32 | Replace "http://localhost:port" with the address your homeserver will use to talk with matrix-appservice-mumble. 33 | The port matrix-appservice-mumble uses can be set with -p. (Default is 8090) 34 | 35 | ```bash 36 | matrix-appservice-mumble -r -u "http://localhost:port" 37 | ``` 38 | 39 | 2. Copy `mumble-registration.yaml` to your homeserver install directory, e.g. `/etc/matrix-synapse/` 40 | 41 | 3. Edit `homeserver.yaml` and add the path to the just generated `mumble-registration.yaml`. 42 | 43 | ```yaml 44 | # A list of application service config files to use 45 | app_service_config_files: 46 | - /etc/matrix-synapse/mumble-registration.yaml 47 | ``` 48 | 49 | 4. Create a new file named `mumble-config.yaml` on the server that `matrix-appservice-mumble` is installed on. 50 | 51 | - Copy the contents of [mumble-config.yaml.example](https://github.com/mymindstorm/matrix-appservice-mumble/blob/master/mumble-config.yaml.example) into `mumble-config.yaml` and change the options as needed. 52 | 53 | - `matrixRoom` should be a private room 54 | 55 | 1. Create a new room (should be invite-only, which is the default) 56 | 57 | 2. Invite `@mumblebot:` to the room. Your client may warn you that the user does not exist, click "Invite anyway" 58 | 59 | 3. Copy the internal room id of the newly created room to `mumble-config.yaml` 60 | 61 | 5. Start the bridge 62 | 63 | ```bash 64 | $ matrix-appservice-mumble -c /path/to/mumble-config.yaml -f /path/to/mumble-registration.yaml 65 | ``` 66 | 67 | 6. Link a room to a channel 68 | 69 | 1. You should see a message from the bot in `matrixRoom` after it has successfully started up 70 | 71 | 2. Send a link command to the admin room (`matrixRoom`). Type `help` to get a list of all commands. 72 | 73 | ```yaml 74 | # To link the topmost (root) Mumble channel 75 | link root_channel 76 | # To link a subchannel 77 | link 78 | # To link the root channel and send join/leave messages 79 | link root_channel true 80 | # To link a subchannel and send join/leave messages 81 | link true 82 | ``` 83 | ### Troubleshooting 84 | 85 | #### Bridge Startup 86 | 87 | - `Unhandled rejection Error: Failed to join room` on bridge startup 88 | - This means that the bot cannot join `matrixRoom`. Make sure that the bot has access (I.e. has the bot been invited) to the room. 89 | - Check the homeserver logs (e.g. `/var/log/matrix-synapse/homeserver.log`) for more information 90 | 91 | #### Matrix -> Murmr not working 92 | 93 | - Can you curl `url` in `mumble-config.yaml` from the homeserver? 94 | - Check firewall configuration 95 | - Check if matrix-appservice-mumble is running 96 | - Check logs 97 | - Check `mumble-registration.yaml` on both sides (should be in working directory of matrix-appservice-mumble and on homeserver) 98 | -------------------------------------------------------------------------------- /bin/matrix-appservice-mumble: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | require('../build/main.js') 3 | -------------------------------------------------------------------------------- /build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -e 4 | rm -rf build 5 | 6 | ./node_modules/.bin/tsc 7 | cp ./lib/* ./build/ 8 | -------------------------------------------------------------------------------- /gen-bindings.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # Use to regenerate the files in ./lib after updating 4 | # MurmurRPC.proto. Must have protoc installed 5 | 6 | set -e 7 | 8 | ./node_modules/.bin/grpc_tools_node_protoc \ 9 | --js_out=import_style=commonjs,binary:./lib \ 10 | --grpc_out=generate_package_definition:./lib \ 11 | -I ./lib \ 12 | ./lib/*.proto 13 | 14 | ./node_modules/.bin/grpc_tools_node_protoc \ 15 | --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts \ 16 | --ts_out=generate_package_definition:./lib \ 17 | -I ./lib \ 18 | ./lib/*.proto 19 | -------------------------------------------------------------------------------- /lib/MurmurRPC.proto: -------------------------------------------------------------------------------- 1 | // Copyright 2005-2019 The Mumble Developers. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license 3 | // that can be found in the LICENSE file at the root of the 4 | // Mumble source tree or at . 5 | 6 | syntax = "proto2"; 7 | 8 | package MurmurRPC; 9 | 10 | // Note about embedded messages: 11 | // 12 | // To help save bandwidth, the protocol does not always send complete embedded 13 | // messages (i.e. an embeddded message with all of the fields filled in). These 14 | // incomplete messages only contain enough identifying information to get more 15 | // information from the message's corresponding "Get" method. For example: 16 | // 17 | // User.server only ever contains the server ID. Calling ServerGet(User.server) 18 | // will return a Server message with the server's status and uptime. 19 | 20 | message Void { 21 | } 22 | 23 | message Version { 24 | // 2-byte Major, 1-byte Minor and 1-byte Patch version number. 25 | optional uint32 version = 1; 26 | // Client release name. 27 | optional string release = 2; 28 | // Client OS name. 29 | optional string os = 3; 30 | // Client OS version. 31 | optional string os_version = 4; 32 | } 33 | 34 | message Uptime { 35 | // The number of seconds from the starting time. 36 | optional uint64 secs = 1; 37 | } 38 | 39 | message Server { 40 | // The unique server ID. 41 | required uint32 id = 1; 42 | // Is the server currently running? 43 | optional bool running = 2; 44 | // The update of the server. 45 | optional Uptime uptime = 3; 46 | 47 | message Event { 48 | enum Type { 49 | UserConnected = 0; 50 | UserDisconnected = 1; 51 | UserStateChanged = 2; 52 | UserTextMessage = 3; 53 | ChannelCreated = 4; 54 | ChannelRemoved = 5; 55 | ChannelStateChanged = 6; 56 | }; 57 | // The server on which the event happened. 58 | optional Server server = 1; 59 | // The type of event that happened. 60 | optional Type type = 2; 61 | // The user tied to the event (if applicable). 62 | optional User user = 3; 63 | // The text message tied to the event (if applicable). 64 | optional TextMessage message = 4; 65 | // The channel tied to the event (if applicable). 66 | optional Channel channel = 5; 67 | } 68 | 69 | message Query { 70 | } 71 | 72 | message List { 73 | // The servers. 74 | repeated Server servers = 1; 75 | } 76 | } 77 | 78 | message Event { 79 | enum Type { 80 | ServerStopped = 0; 81 | ServerStarted = 1; 82 | }; 83 | // The server for which the event happened. 84 | optional Server server = 1; 85 | // The type of event that happened. 86 | optional Type type = 2; 87 | } 88 | 89 | message ContextAction { 90 | enum Context { 91 | Server = 0x01; 92 | Channel = 0x02; 93 | User = 0x04; 94 | }; 95 | // The server on which the action is. 96 | optional Server server = 1; 97 | // The context in which the action is. 98 | optional uint32 context = 2; 99 | // The action name. 100 | optional string action = 3; 101 | // The user-visible descriptive name of the action. 102 | optional string text = 4; 103 | // The user that triggered the ContextAction. 104 | optional User actor = 5; 105 | // The user on which the ContextAction was triggered. 106 | optional User user = 6; 107 | // The channel on which the ContextAction was triggered. 108 | optional Channel channel = 7; 109 | } 110 | 111 | message TextMessage { 112 | // The server on which the TextMessage originates. 113 | optional Server server = 1; 114 | // The user who sent the message. 115 | optional User actor = 2; 116 | // The users to whom the message is sent. 117 | repeated User users = 3; 118 | // The channels to which the message is sent. 119 | repeated Channel channels = 4; 120 | // The channels to which the message is sent, including the channels' 121 | // ancestors. 122 | repeated Channel trees = 5; 123 | // The message body that is sent. 124 | optional string text = 6; 125 | 126 | message Filter { 127 | enum Action { 128 | // Accept the message. 129 | Accept = 0; 130 | // Reject the message with a permission error. 131 | Reject = 1; 132 | // Silently drop the message. 133 | Drop = 2; 134 | } 135 | // The server on which the message originated. 136 | optional Server server = 1; 137 | // The action to perform for the message. 138 | optional Action action = 2; 139 | // The text message. 140 | optional TextMessage message = 3; 141 | } 142 | } 143 | 144 | message Log { 145 | // The server on which the log message was generated. 146 | optional Server server = 1; 147 | // The unix timestamp of when the message was generated. 148 | optional int64 timestamp = 2; 149 | // The log message. 150 | optional string text = 3; 151 | 152 | message Query { 153 | // The server whose logs will be queried. 154 | optional Server server = 1; 155 | // The minimum log index to receive. 156 | optional uint32 min = 2; 157 | // The maximum log index to receive. 158 | optional uint32 max = 3; 159 | } 160 | 161 | message List { 162 | // The server where the log entries are from. 163 | optional Server server = 1; 164 | // The total number of logs entries on the server. 165 | optional uint32 total = 2; 166 | // The minimum log index that was sent. 167 | optional uint32 min = 3; 168 | // The maximum log index that was sent. 169 | optional uint32 max = 4; 170 | // The log entries. 171 | repeated Log entries = 5; 172 | } 173 | } 174 | 175 | message Config { 176 | // The server for which the configuration is for. 177 | optional Server server = 1; 178 | // The configuration keys and values. 179 | map fields = 2; 180 | 181 | message Field { 182 | // The server for which the configuration field is for. 183 | optional Server server = 1; 184 | // The field key. 185 | optional string key = 2; 186 | // The field value. 187 | optional string value = 3; 188 | } 189 | } 190 | 191 | message Channel { 192 | // The server on which the channel exists. 193 | optional Server server = 1; 194 | // The unique channel identifier. 195 | optional uint32 id = 2; 196 | // The channel name. 197 | optional string name = 3; 198 | // The channel's parent. 199 | optional Channel parent = 4; 200 | // Linked channels. 201 | repeated Channel links = 5; 202 | // The channel's description. 203 | optional string description = 6; 204 | // Is the channel temporary? 205 | optional bool temporary = 7; 206 | // The position in which the channel should appear in a sorted list. 207 | optional int32 position = 8; 208 | 209 | message Query { 210 | // The server on which the channels are. 211 | optional Server server = 1; 212 | } 213 | 214 | message List { 215 | // The server on which the channels are. 216 | optional Server server = 1; 217 | // The channels. 218 | repeated Channel channels = 2; 219 | } 220 | } 221 | 222 | message User { 223 | // The server to which the user is connected. 224 | optional Server server = 1; 225 | // The user's session ID. 226 | optional uint32 session = 2; 227 | // The user's registered ID. 228 | optional uint32 id = 3; 229 | // The user's name. 230 | optional string name = 4; 231 | // Is the user muted? 232 | optional bool mute = 5; 233 | // Is the user deafened? 234 | optional bool deaf = 6; 235 | // Is the user suppressed? 236 | optional bool suppress = 7; 237 | // Is the user a priority speaker? 238 | optional bool priority_speaker = 8; 239 | // Has the user muted him/herself? 240 | optional bool self_mute = 9; 241 | // Has the user muted him/herself? 242 | optional bool self_deaf = 10; 243 | // Is the user recording? 244 | optional bool recording = 11; 245 | // The channel the user is in. 246 | optional Channel channel = 12; 247 | // How long the user has been connected to the server. 248 | optional uint32 online_secs = 13; 249 | // How long the user has been idle on the server. 250 | optional uint32 idle_secs = 14; 251 | // How many bytes per second is the user transmitting to the server. 252 | optional uint32 bytes_per_sec = 15; 253 | // The user's client version. 254 | optional Version version = 16; 255 | // The user's plugin context. 256 | optional bytes plugin_context = 17; 257 | // The user's plugin identity. 258 | optional string plugin_identity = 18; 259 | // The user's comment. 260 | optional string comment = 19; 261 | // The user's texture. 262 | optional bytes texture = 20; 263 | // The user's IP address. 264 | optional bytes address = 21; 265 | // Is the user in TCP-only mode? 266 | optional bool tcp_only = 22; 267 | // The user's UDP ping in milliseconds. 268 | optional float udp_ping_msecs = 23; 269 | // The user's TCP ping in milliseconds. 270 | optional float tcp_ping_msecs = 24; 271 | 272 | message Query { 273 | // The server whose users will be queried. 274 | optional Server server = 1; 275 | } 276 | 277 | message List { 278 | // The server to which the users are connected. 279 | optional Server server = 1; 280 | // The users. 281 | repeated User users = 2; 282 | } 283 | 284 | message Kick { 285 | // The server to which the user is connected. 286 | optional Server server = 1; 287 | // The user to kick. 288 | optional User user = 2; 289 | // The user who performed the kick. 290 | optional User actor = 3; 291 | // The reason for why the user is being kicked. 292 | optional string reason = 4; 293 | } 294 | } 295 | 296 | message Tree { 297 | // The server which the tree represents. 298 | optional Server server = 1; 299 | // The current channel. 300 | optional Channel channel = 2; 301 | // Channels below the current channel. 302 | repeated Tree children = 3; 303 | // The users in the current channel. 304 | repeated User users = 4; 305 | 306 | message Query { 307 | // The server to query. 308 | optional Server server = 1; 309 | } 310 | } 311 | 312 | message Ban { 313 | // The server on which the ban is applied. 314 | optional Server server = 1; 315 | // The banned IP address. 316 | optional bytes address = 2; 317 | // The number of leading bits in the address to which the ban applies. 318 | optional uint32 bits = 3; 319 | // The name of the banned user. 320 | optional string name = 4; 321 | // The certificate hash of the banned user. 322 | optional string hash = 5; 323 | // The reason for the ban. 324 | optional string reason = 6; 325 | // The ban start time (in epoch form). 326 | optional int64 start = 7; 327 | // The ban duration. 328 | optional int64 duration_secs = 8; 329 | 330 | message Query { 331 | // The server whose bans to query. 332 | optional Server server = 1; 333 | } 334 | 335 | message List { 336 | // The server for which the bans apply. 337 | optional Server server = 1; 338 | // The bans. 339 | repeated Ban bans = 2; 340 | } 341 | } 342 | 343 | message ACL { 344 | enum Permission { 345 | None = 0x00; 346 | Write = 0x01; 347 | Traverse = 0x02; 348 | Enter = 0x04; 349 | Speak = 0x08; 350 | Whisper = 0x100; 351 | MuteDeafen = 0x10; 352 | Move = 0x20; 353 | MakeChannel = 0x40; 354 | MakeTemporaryChannel = 0x400; 355 | LinkChannel = 0x80; 356 | TextMessage = 0x200; 357 | 358 | Kick = 0x10000; 359 | Ban = 0x20000; 360 | Register = 0x40000; 361 | RegisterSelf = 0x80000; 362 | } 363 | 364 | message Group { 365 | // The ACL group name. 366 | optional string name = 1; 367 | // Is the group inherited? 368 | optional bool inherited = 2; 369 | // Does the group inherit members? 370 | optional bool inherit = 3; 371 | // Can this group be inherited by its children? 372 | optional bool inheritable = 4; 373 | 374 | // The users explicitly added by this group. 375 | repeated DatabaseUser users_add = 5; 376 | // The users explicitly removed by this group. 377 | repeated DatabaseUser users_remove = 6; 378 | // All of the users who are part of this group. 379 | repeated DatabaseUser users = 7; 380 | } 381 | 382 | // Does the ACL apply to the current channel? 383 | optional bool apply_here = 3; 384 | // Does the ACL apply to the current channel's sub-channels? 385 | optional bool apply_subs = 4; 386 | // Was the ACL inherited? 387 | optional bool inherited = 5; 388 | 389 | // The user to whom the ACL applies. 390 | optional DatabaseUser user = 6; 391 | // The group to whom the ACL applies. 392 | optional ACL.Group group = 7; 393 | 394 | // The permissions granted by the ACL (bitmask of ACL.Permission). 395 | optional uint32 allow = 8; 396 | // The permissions denied by the ACL (bitmask of ACL.Permission). 397 | optional uint32 deny = 9; 398 | 399 | message Query { 400 | // The server where the user and channel exist. 401 | optional Server server = 1; 402 | // The user to query. 403 | optional User user = 2; 404 | // The channel to query. 405 | optional Channel channel = 3; 406 | } 407 | 408 | message List { 409 | // The server on which the ACLs exist. 410 | optional Server server = 1; 411 | // The channel to which the ACL refers. 412 | optional Channel channel = 2; 413 | // The ACLs part of the given channel. 414 | repeated ACL acls = 3; 415 | // The groups part of the given channel. 416 | repeated ACL.Group groups = 4; 417 | // Should ACLs be inherited from the parent channel. 418 | optional bool inherit = 5; 419 | } 420 | 421 | message TemporaryGroup { 422 | // The server where the temporary group exists. 423 | optional Server server = 1; 424 | // The channel to which the temporary user group is added. 425 | optional Channel channel = 2; 426 | // The user who is added to the group. 427 | optional User user = 3; 428 | // The name of the temporary group. 429 | optional string name = 4; 430 | } 431 | } 432 | 433 | message Authenticator { 434 | message Request { 435 | // An authentication request for a connecting user. 436 | message Authenticate { 437 | // The user's name. 438 | optional string name = 1; 439 | // The user's password. 440 | optional string password = 2; 441 | // The user's certificate chain in DER format. 442 | repeated bytes certificates = 3; 443 | // The hexadecimal hash of the user's certificate. 444 | optional string certificate_hash = 4; 445 | // If the user is connecting with a strong certificate. 446 | optional bool strong_certificate = 5; 447 | } 448 | 449 | // A request for information about a user, given by either the user's ID 450 | // or name. 451 | message Find { 452 | // The user's ID used for lookup. 453 | optional uint32 id = 1; 454 | // The user's name used for lookup. 455 | optional string name = 2; 456 | } 457 | 458 | // A query of all the registered users, optionally filtered by the given 459 | // filter string. 460 | message Query { 461 | // A user name filter (% is often used as a wildcard) 462 | optional string filter = 1; 463 | } 464 | 465 | // A request for a new user registration. 466 | message Register { 467 | // The database user to register. 468 | optional DatabaseUser user = 1; 469 | } 470 | 471 | // A request for deregistering a registered user. 472 | message Deregister { 473 | // The database user to deregister. 474 | optional DatabaseUser user = 1; 475 | } 476 | 477 | // A request to update a registered user's information. The information 478 | // provided should be merged with existing data. 479 | message Update { 480 | // The database user to update. 481 | optional DatabaseUser user = 1; 482 | } 483 | 484 | optional Authenticate authenticate = 1; 485 | optional Find find = 2; 486 | optional Query query = 3; 487 | optional Register register = 4; 488 | optional Deregister deregister = 5; 489 | optional Update update = 6; 490 | } 491 | 492 | message Response { 493 | // The initialization for the authenticator stream. This message must be 494 | // sent before authentication requests will start streaming. 495 | message Initialize { 496 | optional Server server = 1; 497 | } 498 | 499 | enum Status { 500 | // The request should fallthrough to murmur's default action. 501 | Fallthrough = 0; 502 | // The request was successful. 503 | Success = 1; 504 | // The request failed; there was some error. 505 | Failure = 2; 506 | // A temporary failure prevented the request from succeeding (e.g. a 507 | // database was unavailable). 508 | TemporaryFailure = 3; 509 | } 510 | 511 | message Authenticate { 512 | // The status of the request. 513 | optional Status status = 1; 514 | // The user's registered ID. 515 | optional uint32 id = 2; 516 | // The corrected user's name; 517 | optional string name = 3; 518 | // Additional ACL groups that the user belongs too. 519 | repeated ACL.Group groups = 4; 520 | } 521 | 522 | message Find { 523 | // The database user (if found). 524 | optional DatabaseUser user = 1; 525 | } 526 | 527 | message Query { 528 | // The matched database users. 529 | repeated DatabaseUser users = 1; 530 | } 531 | 532 | message Register { 533 | // The status of the request. 534 | optional Status status = 1; 535 | // The registered database user (must contain the registered user's ID). 536 | optional DatabaseUser user = 2; 537 | } 538 | 539 | message Deregister { 540 | // The status of the request. 541 | optional Status status = 1; 542 | } 543 | 544 | message Update { 545 | // The status of the request. 546 | optional Status status = 1; 547 | } 548 | 549 | optional Initialize initialize = 1; 550 | optional Authenticate authenticate = 2; 551 | optional Find find = 3; 552 | optional Query query = 4; 553 | optional Register register = 5; 554 | optional Deregister deregister = 6; 555 | optional Update update = 7; 556 | } 557 | } 558 | 559 | message DatabaseUser { 560 | // The server on which the user is registered. 561 | optional Server server = 1; 562 | // The unique user ID. 563 | optional uint32 id = 2; 564 | // The user's name. 565 | optional string name = 3; 566 | // The user's email address. 567 | optional string email = 4; 568 | // The user's comment. 569 | optional string comment = 5; 570 | // The user's certificate hash. 571 | optional string hash = 6; 572 | // The user's password (never sent; used only when updating). 573 | optional string password = 7; 574 | // When the user was last on the server. 575 | optional string last_active = 8; 576 | // The user's texture. 577 | optional bytes texture = 9; 578 | 579 | message Query { 580 | // The server whose users will be queried. 581 | optional Server server = 1; 582 | // A string to filter the users by. 583 | optional string filter = 2; 584 | } 585 | 586 | message List { 587 | // The server on which the users are registered. 588 | optional Server server = 1; 589 | // The users. 590 | repeated DatabaseUser users = 2; 591 | } 592 | 593 | message Verify { 594 | // The server on which the user-password pair will be authenticated. 595 | optional Server server = 1; 596 | // The user's name. 597 | optional string name = 2; 598 | // The user's password. 599 | optional string password = 3; 600 | } 601 | } 602 | 603 | message RedirectWhisperGroup { 604 | // The server on which the whisper redirection will take place. 605 | optional Server server = 1; 606 | // The user to whom the redirection will be applied. 607 | optional User user = 2; 608 | // The source group. 609 | optional ACL.Group source = 3; 610 | // The target group. 611 | optional ACL.Group target = 4; 612 | } 613 | 614 | service V1 { 615 | // 616 | // Meta 617 | // 618 | 619 | // GetUptime returns murmur's uptime. 620 | rpc GetUptime(Void) returns(Uptime); 621 | // GetVersion returns murmur's version. 622 | rpc GetVersion(Void) returns(Version); 623 | // Events returns a stream of murmur events. 624 | rpc Events(Void) returns(stream Event); 625 | 626 | // 627 | // Servers 628 | // 629 | 630 | // ServerCreate creates a new virtual server. The returned server object 631 | // contains the newly created server's ID. 632 | rpc ServerCreate(Void) returns(Server); 633 | // ServerQuery returns a list of servers that match the given query. 634 | rpc ServerQuery(Server.Query) returns(Server.List); 635 | // ServerGet returns information about the given server. 636 | rpc ServerGet(Server) returns(Server); 637 | // ServerStart starts the given stopped server. 638 | rpc ServerStart(Server) returns(Void); 639 | // ServerStop stops the given virtual server. 640 | rpc ServerStop(Server) returns(Void); 641 | // ServerRemove removes the given virtual server and its configuration. 642 | rpc ServerRemove(Server) returns(Void); 643 | // ServerEvents returns a stream of events that happen on the given server. 644 | rpc ServerEvents(Server) returns(stream Server.Event); 645 | 646 | // 647 | // ContextActions 648 | // 649 | 650 | // ContextActionAdd adds a context action to the given user's client. The 651 | // following ContextAction fields must be set: 652 | // context, action, text, and user. 653 | // 654 | // Added context actions are valid until: 655 | // - The context action is removed with ContextActionRemove, or 656 | // - The user disconnects from the server, or 657 | // - The server stops. 658 | rpc ContextActionAdd(ContextAction) returns(Void); 659 | // ContextActionRemove removes a context action from the given user's client. 660 | // The following ContextAction must be set: 661 | // action 662 | // If no user is given, the context action is removed from all users. 663 | rpc ContextActionRemove(ContextAction) returns(Void); 664 | // ContextActionEvents returns a stream of context action events that are 665 | // triggered by users. 666 | rpc ContextActionEvents(ContextAction) returns(stream ContextAction); 667 | 668 | // 669 | // TextMessage 670 | // 671 | 672 | // TextMessageSend sends the given TextMessage to the server. 673 | // 674 | // If no users, channels, or trees are added to the TextMessage, the message 675 | // will be broadcast the entire server. Otherwise, the message will be 676 | // targeted to the specified users, channels, and trees. 677 | rpc TextMessageSend(TextMessage) returns(Void); 678 | // TextMessageFilter filters text messages on a given server. 679 | 680 | // TextMessageFilter filters text messages for a given server. 681 | // 682 | // When a filter stream is active, text messages sent from users to the 683 | // server are sent over the stream. The RPC client then sends a message back 684 | // on the same stream, containing an action: whether the message should be 685 | // accepted, rejected, or dropped. 686 | // 687 | // To activate the filter stream, an initial TextMessage.Filter message must 688 | // be sent that contains the server on which the filter will be active. 689 | rpc TextMessageFilter(stream TextMessage.Filter) returns(stream TextMessage.Filter); 690 | 691 | // 692 | // Logs 693 | // 694 | 695 | // LogQuery returns a list of log entries from the given server. 696 | // 697 | // To get the total number of log entries, omit min and/or max from the 698 | // query. 699 | rpc LogQuery(Log.Query) returns(Log.List); 700 | 701 | // 702 | // Config 703 | // 704 | 705 | // ConfigGet returns the explicitly set configuration for the given server. 706 | rpc ConfigGet(Server) returns(Config); 707 | // ConfigGetField returns the configuration value for the given key. 708 | rpc ConfigGetField(Config.Field) returns(Config.Field); 709 | // ConfigSetField sets the configuration value to the given value. 710 | rpc ConfigSetField(Config.Field) returns(Void); 711 | // ConfigGetDefault returns the default server configuration. 712 | rpc ConfigGetDefault(Void) returns(Config); 713 | 714 | // 715 | // Channels 716 | // 717 | 718 | // ChannelQuery returns a list of channels that match the given query. 719 | rpc ChannelQuery(Channel.Query) returns(Channel.List); 720 | // ChannelGet returns the channel with the given ID. 721 | rpc ChannelGet(Channel) returns(Channel); 722 | // ChannelAdd adds the channel to the given server. The parent and name of 723 | // the channel must be set. 724 | rpc ChannelAdd(Channel) returns(Channel); 725 | // ChannelRemove removes the given channel from the server. 726 | rpc ChannelRemove(Channel) returns(Void); 727 | // ChannelUpdate updates the given channel's attributes. Only the fields that 728 | // are set will be updated. 729 | rpc ChannelUpdate(Channel) returns(Channel); 730 | 731 | // 732 | // Users 733 | // 734 | 735 | // UserQuery returns a list of connected users who match the given query. 736 | rpc UserQuery(User.Query) returns(User.List); 737 | // UserGet returns information on the connected user, given by the user's 738 | // session or name. 739 | rpc UserGet(User) returns(User); 740 | // UserUpdate changes the given user's state. Only the following fields can 741 | // be changed: 742 | // name, mute, deaf, suppress, priority_speaker, channel, comment. 743 | rpc UserUpdate(User) returns(User); 744 | // UserKick kicks the user from the server. 745 | rpc UserKick(User.Kick) returns(Void); 746 | 747 | // 748 | // Tree 749 | // 750 | 751 | // TreeQuery returns a representation of the given server's channel/user 752 | // tree. 753 | rpc TreeQuery(Tree.Query) returns(Tree); 754 | 755 | // 756 | // Bans 757 | // 758 | 759 | // BansGet returns a list of bans for the given server. 760 | rpc BansGet(Ban.Query) returns(Ban.List); 761 | // BansSet replaces the server's ban list with the given list. 762 | rpc BansSet(Ban.List) returns(Void); 763 | 764 | // 765 | // ACL 766 | // 767 | 768 | // ACLGet returns the ACL for the given channel. 769 | rpc ACLGet(Channel) returns(ACL.List); 770 | // ACLSet overrides the ACL of the given channel to what is provided. 771 | rpc ACLSet(ACL.List) returns(Void); 772 | // ACLGetEffectivePermissions returns the effective permissions for the given 773 | // user in the given channel. 774 | rpc ACLGetEffectivePermissions(ACL.Query) returns(ACL); 775 | // ACLAddTemporaryGroup adds a user to a temporary group. 776 | rpc ACLAddTemporaryGroup(ACL.TemporaryGroup) returns(Void); 777 | // ACLRemoveTemporaryGroup removes a user from a temporary group. 778 | rpc ACLRemoveTemporaryGroup(ACL.TemporaryGroup) returns(Void); 779 | 780 | // 781 | // Authenticator 782 | // 783 | 784 | // AuthenticatorStream opens an authentication stream to the server. 785 | // 786 | // There can only be one RPC client with an open Stream. If a new 787 | // authenticator connects, the open connected will be closed. 788 | rpc AuthenticatorStream(stream Authenticator.Response) returns(stream Authenticator.Request); 789 | 790 | // 791 | // Database 792 | // 793 | 794 | // DatabaseUserQuery returns a list of registered users who match given 795 | // query. 796 | rpc DatabaseUserQuery(DatabaseUser.Query) returns(DatabaseUser.List); 797 | // DatabaseUserGet returns the database user with the given ID. 798 | rpc DatabaseUserGet(DatabaseUser) returns(DatabaseUser); 799 | // DatabaseUserUpdate updates the given database user. 800 | rpc DatabaseUserUpdate(DatabaseUser) returns(Void); 801 | // DatabaseUserRegister registers a user with the given information on the 802 | // server. The returned DatabaseUser will contain the newly registered user's 803 | // ID. 804 | rpc DatabaseUserRegister(DatabaseUser) returns(DatabaseUser); 805 | // DatabaseUserDeregister deregisters the given user. 806 | rpc DatabaseUserDeregister(DatabaseUser) returns(Void); 807 | // DatabaseUserVerify verifies the that the given user-password pair is 808 | // correct. 809 | rpc DatabaseUserVerify(DatabaseUser.Verify) returns(DatabaseUser); 810 | 811 | // 812 | // Audio 813 | // 814 | 815 | // AddRedirectWhisperGroup add a whisper targets redirection for the given 816 | // user. Whenever a user whispers to group "source", the whisper will be 817 | // redirected to group "target". 818 | rpc RedirectWhisperGroupAdd(RedirectWhisperGroup) returns(Void); 819 | 820 | // RemoveRedirectWhisperGroup removes a whisper target redirection for 821 | // the the given user. 822 | rpc RedirectWhisperGroupRemove(RedirectWhisperGroup) returns(Void); 823 | } 824 | -------------------------------------------------------------------------------- /lib/MurmurRPC_grpc_pb.d.ts: -------------------------------------------------------------------------------- 1 | // package: MurmurRPC 2 | // file: MurmurRPC.proto 3 | 4 | /* tslint:disable */ 5 | /* eslint-disable */ 6 | 7 | import * as grpc from "@grpc/grpc-js"; 8 | import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call"; 9 | import * as MurmurRPC_pb from "./MurmurRPC_pb"; 10 | 11 | interface IV1Service extends grpc.ServiceDefinition { 12 | getUptime: IV1Service_IGetUptime; 13 | getVersion: IV1Service_IGetVersion; 14 | events: IV1Service_IEvents; 15 | serverCreate: IV1Service_IServerCreate; 16 | serverQuery: IV1Service_IServerQuery; 17 | serverGet: IV1Service_IServerGet; 18 | serverStart: IV1Service_IServerStart; 19 | serverStop: IV1Service_IServerStop; 20 | serverRemove: IV1Service_IServerRemove; 21 | serverEvents: IV1Service_IServerEvents; 22 | contextActionAdd: IV1Service_IContextActionAdd; 23 | contextActionRemove: IV1Service_IContextActionRemove; 24 | contextActionEvents: IV1Service_IContextActionEvents; 25 | textMessageSend: IV1Service_ITextMessageSend; 26 | textMessageFilter: IV1Service_ITextMessageFilter; 27 | logQuery: IV1Service_ILogQuery; 28 | configGet: IV1Service_IConfigGet; 29 | configGetField: IV1Service_IConfigGetField; 30 | configSetField: IV1Service_IConfigSetField; 31 | configGetDefault: IV1Service_IConfigGetDefault; 32 | channelQuery: IV1Service_IChannelQuery; 33 | channelGet: IV1Service_IChannelGet; 34 | channelAdd: IV1Service_IChannelAdd; 35 | channelRemove: IV1Service_IChannelRemove; 36 | channelUpdate: IV1Service_IChannelUpdate; 37 | userQuery: IV1Service_IUserQuery; 38 | userGet: IV1Service_IUserGet; 39 | userUpdate: IV1Service_IUserUpdate; 40 | userKick: IV1Service_IUserKick; 41 | treeQuery: IV1Service_ITreeQuery; 42 | bansGet: IV1Service_IBansGet; 43 | bansSet: IV1Service_IBansSet; 44 | aCLGet: IV1Service_IACLGet; 45 | aCLSet: IV1Service_IACLSet; 46 | aCLGetEffectivePermissions: IV1Service_IACLGetEffectivePermissions; 47 | aCLAddTemporaryGroup: IV1Service_IACLAddTemporaryGroup; 48 | aCLRemoveTemporaryGroup: IV1Service_IACLRemoveTemporaryGroup; 49 | authenticatorStream: IV1Service_IAuthenticatorStream; 50 | databaseUserQuery: IV1Service_IDatabaseUserQuery; 51 | databaseUserGet: IV1Service_IDatabaseUserGet; 52 | databaseUserUpdate: IV1Service_IDatabaseUserUpdate; 53 | databaseUserRegister: IV1Service_IDatabaseUserRegister; 54 | databaseUserDeregister: IV1Service_IDatabaseUserDeregister; 55 | databaseUserVerify: IV1Service_IDatabaseUserVerify; 56 | redirectWhisperGroupAdd: IV1Service_IRedirectWhisperGroupAdd; 57 | redirectWhisperGroupRemove: IV1Service_IRedirectWhisperGroupRemove; 58 | } 59 | 60 | interface IV1Service_IGetUptime extends grpc.MethodDefinition { 61 | path: string; // "/MurmurRPC.V1/GetUptime" 62 | requestStream: boolean; // false 63 | responseStream: boolean; // false 64 | requestSerialize: grpc.serialize; 65 | requestDeserialize: grpc.deserialize; 66 | responseSerialize: grpc.serialize; 67 | responseDeserialize: grpc.deserialize; 68 | } 69 | interface IV1Service_IGetVersion extends grpc.MethodDefinition { 70 | path: string; // "/MurmurRPC.V1/GetVersion" 71 | requestStream: boolean; // false 72 | responseStream: boolean; // false 73 | requestSerialize: grpc.serialize; 74 | requestDeserialize: grpc.deserialize; 75 | responseSerialize: grpc.serialize; 76 | responseDeserialize: grpc.deserialize; 77 | } 78 | interface IV1Service_IEvents extends grpc.MethodDefinition { 79 | path: string; // "/MurmurRPC.V1/Events" 80 | requestStream: boolean; // false 81 | responseStream: boolean; // true 82 | requestSerialize: grpc.serialize; 83 | requestDeserialize: grpc.deserialize; 84 | responseSerialize: grpc.serialize; 85 | responseDeserialize: grpc.deserialize; 86 | } 87 | interface IV1Service_IServerCreate extends grpc.MethodDefinition { 88 | path: string; // "/MurmurRPC.V1/ServerCreate" 89 | requestStream: boolean; // false 90 | responseStream: boolean; // false 91 | requestSerialize: grpc.serialize; 92 | requestDeserialize: grpc.deserialize; 93 | responseSerialize: grpc.serialize; 94 | responseDeserialize: grpc.deserialize; 95 | } 96 | interface IV1Service_IServerQuery extends grpc.MethodDefinition { 97 | path: string; // "/MurmurRPC.V1/ServerQuery" 98 | requestStream: boolean; // false 99 | responseStream: boolean; // false 100 | requestSerialize: grpc.serialize; 101 | requestDeserialize: grpc.deserialize; 102 | responseSerialize: grpc.serialize; 103 | responseDeserialize: grpc.deserialize; 104 | } 105 | interface IV1Service_IServerGet extends grpc.MethodDefinition { 106 | path: string; // "/MurmurRPC.V1/ServerGet" 107 | requestStream: boolean; // false 108 | responseStream: boolean; // false 109 | requestSerialize: grpc.serialize; 110 | requestDeserialize: grpc.deserialize; 111 | responseSerialize: grpc.serialize; 112 | responseDeserialize: grpc.deserialize; 113 | } 114 | interface IV1Service_IServerStart extends grpc.MethodDefinition { 115 | path: string; // "/MurmurRPC.V1/ServerStart" 116 | requestStream: boolean; // false 117 | responseStream: boolean; // false 118 | requestSerialize: grpc.serialize; 119 | requestDeserialize: grpc.deserialize; 120 | responseSerialize: grpc.serialize; 121 | responseDeserialize: grpc.deserialize; 122 | } 123 | interface IV1Service_IServerStop extends grpc.MethodDefinition { 124 | path: string; // "/MurmurRPC.V1/ServerStop" 125 | requestStream: boolean; // false 126 | responseStream: boolean; // false 127 | requestSerialize: grpc.serialize; 128 | requestDeserialize: grpc.deserialize; 129 | responseSerialize: grpc.serialize; 130 | responseDeserialize: grpc.deserialize; 131 | } 132 | interface IV1Service_IServerRemove extends grpc.MethodDefinition { 133 | path: string; // "/MurmurRPC.V1/ServerRemove" 134 | requestStream: boolean; // false 135 | responseStream: boolean; // false 136 | requestSerialize: grpc.serialize; 137 | requestDeserialize: grpc.deserialize; 138 | responseSerialize: grpc.serialize; 139 | responseDeserialize: grpc.deserialize; 140 | } 141 | interface IV1Service_IServerEvents extends grpc.MethodDefinition { 142 | path: string; // "/MurmurRPC.V1/ServerEvents" 143 | requestStream: boolean; // false 144 | responseStream: boolean; // true 145 | requestSerialize: grpc.serialize; 146 | requestDeserialize: grpc.deserialize; 147 | responseSerialize: grpc.serialize; 148 | responseDeserialize: grpc.deserialize; 149 | } 150 | interface IV1Service_IContextActionAdd extends grpc.MethodDefinition { 151 | path: string; // "/MurmurRPC.V1/ContextActionAdd" 152 | requestStream: boolean; // false 153 | responseStream: boolean; // false 154 | requestSerialize: grpc.serialize; 155 | requestDeserialize: grpc.deserialize; 156 | responseSerialize: grpc.serialize; 157 | responseDeserialize: grpc.deserialize; 158 | } 159 | interface IV1Service_IContextActionRemove extends grpc.MethodDefinition { 160 | path: string; // "/MurmurRPC.V1/ContextActionRemove" 161 | requestStream: boolean; // false 162 | responseStream: boolean; // false 163 | requestSerialize: grpc.serialize; 164 | requestDeserialize: grpc.deserialize; 165 | responseSerialize: grpc.serialize; 166 | responseDeserialize: grpc.deserialize; 167 | } 168 | interface IV1Service_IContextActionEvents extends grpc.MethodDefinition { 169 | path: string; // "/MurmurRPC.V1/ContextActionEvents" 170 | requestStream: boolean; // false 171 | responseStream: boolean; // true 172 | requestSerialize: grpc.serialize; 173 | requestDeserialize: grpc.deserialize; 174 | responseSerialize: grpc.serialize; 175 | responseDeserialize: grpc.deserialize; 176 | } 177 | interface IV1Service_ITextMessageSend extends grpc.MethodDefinition { 178 | path: string; // "/MurmurRPC.V1/TextMessageSend" 179 | requestStream: boolean; // false 180 | responseStream: boolean; // false 181 | requestSerialize: grpc.serialize; 182 | requestDeserialize: grpc.deserialize; 183 | responseSerialize: grpc.serialize; 184 | responseDeserialize: grpc.deserialize; 185 | } 186 | interface IV1Service_ITextMessageFilter extends grpc.MethodDefinition { 187 | path: string; // "/MurmurRPC.V1/TextMessageFilter" 188 | requestStream: boolean; // true 189 | responseStream: boolean; // true 190 | requestSerialize: grpc.serialize; 191 | requestDeserialize: grpc.deserialize; 192 | responseSerialize: grpc.serialize; 193 | responseDeserialize: grpc.deserialize; 194 | } 195 | interface IV1Service_ILogQuery extends grpc.MethodDefinition { 196 | path: string; // "/MurmurRPC.V1/LogQuery" 197 | requestStream: boolean; // false 198 | responseStream: boolean; // false 199 | requestSerialize: grpc.serialize; 200 | requestDeserialize: grpc.deserialize; 201 | responseSerialize: grpc.serialize; 202 | responseDeserialize: grpc.deserialize; 203 | } 204 | interface IV1Service_IConfigGet extends grpc.MethodDefinition { 205 | path: string; // "/MurmurRPC.V1/ConfigGet" 206 | requestStream: boolean; // false 207 | responseStream: boolean; // false 208 | requestSerialize: grpc.serialize; 209 | requestDeserialize: grpc.deserialize; 210 | responseSerialize: grpc.serialize; 211 | responseDeserialize: grpc.deserialize; 212 | } 213 | interface IV1Service_IConfigGetField extends grpc.MethodDefinition { 214 | path: string; // "/MurmurRPC.V1/ConfigGetField" 215 | requestStream: boolean; // false 216 | responseStream: boolean; // false 217 | requestSerialize: grpc.serialize; 218 | requestDeserialize: grpc.deserialize; 219 | responseSerialize: grpc.serialize; 220 | responseDeserialize: grpc.deserialize; 221 | } 222 | interface IV1Service_IConfigSetField extends grpc.MethodDefinition { 223 | path: string; // "/MurmurRPC.V1/ConfigSetField" 224 | requestStream: boolean; // false 225 | responseStream: boolean; // false 226 | requestSerialize: grpc.serialize; 227 | requestDeserialize: grpc.deserialize; 228 | responseSerialize: grpc.serialize; 229 | responseDeserialize: grpc.deserialize; 230 | } 231 | interface IV1Service_IConfigGetDefault extends grpc.MethodDefinition { 232 | path: string; // "/MurmurRPC.V1/ConfigGetDefault" 233 | requestStream: boolean; // false 234 | responseStream: boolean; // false 235 | requestSerialize: grpc.serialize; 236 | requestDeserialize: grpc.deserialize; 237 | responseSerialize: grpc.serialize; 238 | responseDeserialize: grpc.deserialize; 239 | } 240 | interface IV1Service_IChannelQuery extends grpc.MethodDefinition { 241 | path: string; // "/MurmurRPC.V1/ChannelQuery" 242 | requestStream: boolean; // false 243 | responseStream: boolean; // false 244 | requestSerialize: grpc.serialize; 245 | requestDeserialize: grpc.deserialize; 246 | responseSerialize: grpc.serialize; 247 | responseDeserialize: grpc.deserialize; 248 | } 249 | interface IV1Service_IChannelGet extends grpc.MethodDefinition { 250 | path: string; // "/MurmurRPC.V1/ChannelGet" 251 | requestStream: boolean; // false 252 | responseStream: boolean; // false 253 | requestSerialize: grpc.serialize; 254 | requestDeserialize: grpc.deserialize; 255 | responseSerialize: grpc.serialize; 256 | responseDeserialize: grpc.deserialize; 257 | } 258 | interface IV1Service_IChannelAdd extends grpc.MethodDefinition { 259 | path: string; // "/MurmurRPC.V1/ChannelAdd" 260 | requestStream: boolean; // false 261 | responseStream: boolean; // false 262 | requestSerialize: grpc.serialize; 263 | requestDeserialize: grpc.deserialize; 264 | responseSerialize: grpc.serialize; 265 | responseDeserialize: grpc.deserialize; 266 | } 267 | interface IV1Service_IChannelRemove extends grpc.MethodDefinition { 268 | path: string; // "/MurmurRPC.V1/ChannelRemove" 269 | requestStream: boolean; // false 270 | responseStream: boolean; // false 271 | requestSerialize: grpc.serialize; 272 | requestDeserialize: grpc.deserialize; 273 | responseSerialize: grpc.serialize; 274 | responseDeserialize: grpc.deserialize; 275 | } 276 | interface IV1Service_IChannelUpdate extends grpc.MethodDefinition { 277 | path: string; // "/MurmurRPC.V1/ChannelUpdate" 278 | requestStream: boolean; // false 279 | responseStream: boolean; // false 280 | requestSerialize: grpc.serialize; 281 | requestDeserialize: grpc.deserialize; 282 | responseSerialize: grpc.serialize; 283 | responseDeserialize: grpc.deserialize; 284 | } 285 | interface IV1Service_IUserQuery extends grpc.MethodDefinition { 286 | path: string; // "/MurmurRPC.V1/UserQuery" 287 | requestStream: boolean; // false 288 | responseStream: boolean; // false 289 | requestSerialize: grpc.serialize; 290 | requestDeserialize: grpc.deserialize; 291 | responseSerialize: grpc.serialize; 292 | responseDeserialize: grpc.deserialize; 293 | } 294 | interface IV1Service_IUserGet extends grpc.MethodDefinition { 295 | path: string; // "/MurmurRPC.V1/UserGet" 296 | requestStream: boolean; // false 297 | responseStream: boolean; // false 298 | requestSerialize: grpc.serialize; 299 | requestDeserialize: grpc.deserialize; 300 | responseSerialize: grpc.serialize; 301 | responseDeserialize: grpc.deserialize; 302 | } 303 | interface IV1Service_IUserUpdate extends grpc.MethodDefinition { 304 | path: string; // "/MurmurRPC.V1/UserUpdate" 305 | requestStream: boolean; // false 306 | responseStream: boolean; // false 307 | requestSerialize: grpc.serialize; 308 | requestDeserialize: grpc.deserialize; 309 | responseSerialize: grpc.serialize; 310 | responseDeserialize: grpc.deserialize; 311 | } 312 | interface IV1Service_IUserKick extends grpc.MethodDefinition { 313 | path: string; // "/MurmurRPC.V1/UserKick" 314 | requestStream: boolean; // false 315 | responseStream: boolean; // false 316 | requestSerialize: grpc.serialize; 317 | requestDeserialize: grpc.deserialize; 318 | responseSerialize: grpc.serialize; 319 | responseDeserialize: grpc.deserialize; 320 | } 321 | interface IV1Service_ITreeQuery extends grpc.MethodDefinition { 322 | path: string; // "/MurmurRPC.V1/TreeQuery" 323 | requestStream: boolean; // false 324 | responseStream: boolean; // false 325 | requestSerialize: grpc.serialize; 326 | requestDeserialize: grpc.deserialize; 327 | responseSerialize: grpc.serialize; 328 | responseDeserialize: grpc.deserialize; 329 | } 330 | interface IV1Service_IBansGet extends grpc.MethodDefinition { 331 | path: string; // "/MurmurRPC.V1/BansGet" 332 | requestStream: boolean; // false 333 | responseStream: boolean; // false 334 | requestSerialize: grpc.serialize; 335 | requestDeserialize: grpc.deserialize; 336 | responseSerialize: grpc.serialize; 337 | responseDeserialize: grpc.deserialize; 338 | } 339 | interface IV1Service_IBansSet extends grpc.MethodDefinition { 340 | path: string; // "/MurmurRPC.V1/BansSet" 341 | requestStream: boolean; // false 342 | responseStream: boolean; // false 343 | requestSerialize: grpc.serialize; 344 | requestDeserialize: grpc.deserialize; 345 | responseSerialize: grpc.serialize; 346 | responseDeserialize: grpc.deserialize; 347 | } 348 | interface IV1Service_IACLGet extends grpc.MethodDefinition { 349 | path: string; // "/MurmurRPC.V1/ACLGet" 350 | requestStream: boolean; // false 351 | responseStream: boolean; // false 352 | requestSerialize: grpc.serialize; 353 | requestDeserialize: grpc.deserialize; 354 | responseSerialize: grpc.serialize; 355 | responseDeserialize: grpc.deserialize; 356 | } 357 | interface IV1Service_IACLSet extends grpc.MethodDefinition { 358 | path: string; // "/MurmurRPC.V1/ACLSet" 359 | requestStream: boolean; // false 360 | responseStream: boolean; // false 361 | requestSerialize: grpc.serialize; 362 | requestDeserialize: grpc.deserialize; 363 | responseSerialize: grpc.serialize; 364 | responseDeserialize: grpc.deserialize; 365 | } 366 | interface IV1Service_IACLGetEffectivePermissions extends grpc.MethodDefinition { 367 | path: string; // "/MurmurRPC.V1/ACLGetEffectivePermissions" 368 | requestStream: boolean; // false 369 | responseStream: boolean; // false 370 | requestSerialize: grpc.serialize; 371 | requestDeserialize: grpc.deserialize; 372 | responseSerialize: grpc.serialize; 373 | responseDeserialize: grpc.deserialize; 374 | } 375 | interface IV1Service_IACLAddTemporaryGroup extends grpc.MethodDefinition { 376 | path: string; // "/MurmurRPC.V1/ACLAddTemporaryGroup" 377 | requestStream: boolean; // false 378 | responseStream: boolean; // false 379 | requestSerialize: grpc.serialize; 380 | requestDeserialize: grpc.deserialize; 381 | responseSerialize: grpc.serialize; 382 | responseDeserialize: grpc.deserialize; 383 | } 384 | interface IV1Service_IACLRemoveTemporaryGroup extends grpc.MethodDefinition { 385 | path: string; // "/MurmurRPC.V1/ACLRemoveTemporaryGroup" 386 | requestStream: boolean; // false 387 | responseStream: boolean; // false 388 | requestSerialize: grpc.serialize; 389 | requestDeserialize: grpc.deserialize; 390 | responseSerialize: grpc.serialize; 391 | responseDeserialize: grpc.deserialize; 392 | } 393 | interface IV1Service_IAuthenticatorStream extends grpc.MethodDefinition { 394 | path: string; // "/MurmurRPC.V1/AuthenticatorStream" 395 | requestStream: boolean; // true 396 | responseStream: boolean; // true 397 | requestSerialize: grpc.serialize; 398 | requestDeserialize: grpc.deserialize; 399 | responseSerialize: grpc.serialize; 400 | responseDeserialize: grpc.deserialize; 401 | } 402 | interface IV1Service_IDatabaseUserQuery extends grpc.MethodDefinition { 403 | path: string; // "/MurmurRPC.V1/DatabaseUserQuery" 404 | requestStream: boolean; // false 405 | responseStream: boolean; // false 406 | requestSerialize: grpc.serialize; 407 | requestDeserialize: grpc.deserialize; 408 | responseSerialize: grpc.serialize; 409 | responseDeserialize: grpc.deserialize; 410 | } 411 | interface IV1Service_IDatabaseUserGet extends grpc.MethodDefinition { 412 | path: string; // "/MurmurRPC.V1/DatabaseUserGet" 413 | requestStream: boolean; // false 414 | responseStream: boolean; // false 415 | requestSerialize: grpc.serialize; 416 | requestDeserialize: grpc.deserialize; 417 | responseSerialize: grpc.serialize; 418 | responseDeserialize: grpc.deserialize; 419 | } 420 | interface IV1Service_IDatabaseUserUpdate extends grpc.MethodDefinition { 421 | path: string; // "/MurmurRPC.V1/DatabaseUserUpdate" 422 | requestStream: boolean; // false 423 | responseStream: boolean; // false 424 | requestSerialize: grpc.serialize; 425 | requestDeserialize: grpc.deserialize; 426 | responseSerialize: grpc.serialize; 427 | responseDeserialize: grpc.deserialize; 428 | } 429 | interface IV1Service_IDatabaseUserRegister extends grpc.MethodDefinition { 430 | path: string; // "/MurmurRPC.V1/DatabaseUserRegister" 431 | requestStream: boolean; // false 432 | responseStream: boolean; // false 433 | requestSerialize: grpc.serialize; 434 | requestDeserialize: grpc.deserialize; 435 | responseSerialize: grpc.serialize; 436 | responseDeserialize: grpc.deserialize; 437 | } 438 | interface IV1Service_IDatabaseUserDeregister extends grpc.MethodDefinition { 439 | path: string; // "/MurmurRPC.V1/DatabaseUserDeregister" 440 | requestStream: boolean; // false 441 | responseStream: boolean; // false 442 | requestSerialize: grpc.serialize; 443 | requestDeserialize: grpc.deserialize; 444 | responseSerialize: grpc.serialize; 445 | responseDeserialize: grpc.deserialize; 446 | } 447 | interface IV1Service_IDatabaseUserVerify extends grpc.MethodDefinition { 448 | path: string; // "/MurmurRPC.V1/DatabaseUserVerify" 449 | requestStream: boolean; // false 450 | responseStream: boolean; // false 451 | requestSerialize: grpc.serialize; 452 | requestDeserialize: grpc.deserialize; 453 | responseSerialize: grpc.serialize; 454 | responseDeserialize: grpc.deserialize; 455 | } 456 | interface IV1Service_IRedirectWhisperGroupAdd extends grpc.MethodDefinition { 457 | path: string; // "/MurmurRPC.V1/RedirectWhisperGroupAdd" 458 | requestStream: boolean; // false 459 | responseStream: boolean; // false 460 | requestSerialize: grpc.serialize; 461 | requestDeserialize: grpc.deserialize; 462 | responseSerialize: grpc.serialize; 463 | responseDeserialize: grpc.deserialize; 464 | } 465 | interface IV1Service_IRedirectWhisperGroupRemove extends grpc.MethodDefinition { 466 | path: string; // "/MurmurRPC.V1/RedirectWhisperGroupRemove" 467 | requestStream: boolean; // false 468 | responseStream: boolean; // false 469 | requestSerialize: grpc.serialize; 470 | requestDeserialize: grpc.deserialize; 471 | responseSerialize: grpc.serialize; 472 | responseDeserialize: grpc.deserialize; 473 | } 474 | 475 | export const V1Service: IV1Service; 476 | 477 | export interface IV1Server { 478 | getUptime: grpc.handleUnaryCall; 479 | getVersion: grpc.handleUnaryCall; 480 | events: grpc.handleServerStreamingCall; 481 | serverCreate: grpc.handleUnaryCall; 482 | serverQuery: grpc.handleUnaryCall; 483 | serverGet: grpc.handleUnaryCall; 484 | serverStart: grpc.handleUnaryCall; 485 | serverStop: grpc.handleUnaryCall; 486 | serverRemove: grpc.handleUnaryCall; 487 | serverEvents: grpc.handleServerStreamingCall; 488 | contextActionAdd: grpc.handleUnaryCall; 489 | contextActionRemove: grpc.handleUnaryCall; 490 | contextActionEvents: grpc.handleServerStreamingCall; 491 | textMessageSend: grpc.handleUnaryCall; 492 | textMessageFilter: grpc.handleBidiStreamingCall; 493 | logQuery: grpc.handleUnaryCall; 494 | configGet: grpc.handleUnaryCall; 495 | configGetField: grpc.handleUnaryCall; 496 | configSetField: grpc.handleUnaryCall; 497 | configGetDefault: grpc.handleUnaryCall; 498 | channelQuery: grpc.handleUnaryCall; 499 | channelGet: grpc.handleUnaryCall; 500 | channelAdd: grpc.handleUnaryCall; 501 | channelRemove: grpc.handleUnaryCall; 502 | channelUpdate: grpc.handleUnaryCall; 503 | userQuery: grpc.handleUnaryCall; 504 | userGet: grpc.handleUnaryCall; 505 | userUpdate: grpc.handleUnaryCall; 506 | userKick: grpc.handleUnaryCall; 507 | treeQuery: grpc.handleUnaryCall; 508 | bansGet: grpc.handleUnaryCall; 509 | bansSet: grpc.handleUnaryCall; 510 | aCLGet: grpc.handleUnaryCall; 511 | aCLSet: grpc.handleUnaryCall; 512 | aCLGetEffectivePermissions: grpc.handleUnaryCall; 513 | aCLAddTemporaryGroup: grpc.handleUnaryCall; 514 | aCLRemoveTemporaryGroup: grpc.handleUnaryCall; 515 | authenticatorStream: grpc.handleBidiStreamingCall; 516 | databaseUserQuery: grpc.handleUnaryCall; 517 | databaseUserGet: grpc.handleUnaryCall; 518 | databaseUserUpdate: grpc.handleUnaryCall; 519 | databaseUserRegister: grpc.handleUnaryCall; 520 | databaseUserDeregister: grpc.handleUnaryCall; 521 | databaseUserVerify: grpc.handleUnaryCall; 522 | redirectWhisperGroupAdd: grpc.handleUnaryCall; 523 | redirectWhisperGroupRemove: grpc.handleUnaryCall; 524 | } 525 | 526 | export interface IV1Client { 527 | getUptime(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 528 | getUptime(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 529 | getUptime(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 530 | getVersion(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 531 | getVersion(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 532 | getVersion(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 533 | events(request: MurmurRPC_pb.Void, options?: Partial): grpc.ClientReadableStream; 534 | events(request: MurmurRPC_pb.Void, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 535 | serverCreate(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 536 | serverCreate(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 537 | serverCreate(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 538 | serverQuery(request: MurmurRPC_pb.Server.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 539 | serverQuery(request: MurmurRPC_pb.Server.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 540 | serverQuery(request: MurmurRPC_pb.Server.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 541 | serverGet(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 542 | serverGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 543 | serverGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 544 | serverStart(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 545 | serverStart(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 546 | serverStart(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 547 | serverStop(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 548 | serverStop(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 549 | serverStop(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 550 | serverRemove(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 551 | serverRemove(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 552 | serverRemove(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 553 | serverEvents(request: MurmurRPC_pb.Server, options?: Partial): grpc.ClientReadableStream; 554 | serverEvents(request: MurmurRPC_pb.Server, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 555 | contextActionAdd(request: MurmurRPC_pb.ContextAction, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 556 | contextActionAdd(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 557 | contextActionAdd(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 558 | contextActionRemove(request: MurmurRPC_pb.ContextAction, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 559 | contextActionRemove(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 560 | contextActionRemove(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 561 | contextActionEvents(request: MurmurRPC_pb.ContextAction, options?: Partial): grpc.ClientReadableStream; 562 | contextActionEvents(request: MurmurRPC_pb.ContextAction, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 563 | textMessageSend(request: MurmurRPC_pb.TextMessage, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 564 | textMessageSend(request: MurmurRPC_pb.TextMessage, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 565 | textMessageSend(request: MurmurRPC_pb.TextMessage, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 566 | textMessageFilter(): grpc.ClientDuplexStream; 567 | textMessageFilter(options: Partial): grpc.ClientDuplexStream; 568 | textMessageFilter(metadata: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; 569 | logQuery(request: MurmurRPC_pb.Log.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 570 | logQuery(request: MurmurRPC_pb.Log.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 571 | logQuery(request: MurmurRPC_pb.Log.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 572 | configGet(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 573 | configGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 574 | configGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 575 | configGetField(request: MurmurRPC_pb.Config.Field, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 576 | configGetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 577 | configGetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 578 | configSetField(request: MurmurRPC_pb.Config.Field, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 579 | configSetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 580 | configSetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 581 | configGetDefault(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 582 | configGetDefault(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 583 | configGetDefault(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 584 | channelQuery(request: MurmurRPC_pb.Channel.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 585 | channelQuery(request: MurmurRPC_pb.Channel.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 586 | channelQuery(request: MurmurRPC_pb.Channel.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 587 | channelGet(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 588 | channelGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 589 | channelGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 590 | channelAdd(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 591 | channelAdd(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 592 | channelAdd(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 593 | channelRemove(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 594 | channelRemove(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 595 | channelRemove(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 596 | channelUpdate(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 597 | channelUpdate(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 598 | channelUpdate(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 599 | userQuery(request: MurmurRPC_pb.User.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 600 | userQuery(request: MurmurRPC_pb.User.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 601 | userQuery(request: MurmurRPC_pb.User.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 602 | userGet(request: MurmurRPC_pb.User, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 603 | userGet(request: MurmurRPC_pb.User, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 604 | userGet(request: MurmurRPC_pb.User, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 605 | userUpdate(request: MurmurRPC_pb.User, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 606 | userUpdate(request: MurmurRPC_pb.User, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 607 | userUpdate(request: MurmurRPC_pb.User, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 608 | userKick(request: MurmurRPC_pb.User.Kick, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 609 | userKick(request: MurmurRPC_pb.User.Kick, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 610 | userKick(request: MurmurRPC_pb.User.Kick, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 611 | treeQuery(request: MurmurRPC_pb.Tree.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 612 | treeQuery(request: MurmurRPC_pb.Tree.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 613 | treeQuery(request: MurmurRPC_pb.Tree.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 614 | bansGet(request: MurmurRPC_pb.Ban.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 615 | bansGet(request: MurmurRPC_pb.Ban.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 616 | bansGet(request: MurmurRPC_pb.Ban.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 617 | bansSet(request: MurmurRPC_pb.Ban.List, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 618 | bansSet(request: MurmurRPC_pb.Ban.List, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 619 | bansSet(request: MurmurRPC_pb.Ban.List, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 620 | aCLGet(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 621 | aCLGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 622 | aCLGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 623 | aCLSet(request: MurmurRPC_pb.ACL.List, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 624 | aCLSet(request: MurmurRPC_pb.ACL.List, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 625 | aCLSet(request: MurmurRPC_pb.ACL.List, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 626 | aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 627 | aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 628 | aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 629 | aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 630 | aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 631 | aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 632 | aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 633 | aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 634 | aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 635 | authenticatorStream(): grpc.ClientDuplexStream; 636 | authenticatorStream(options: Partial): grpc.ClientDuplexStream; 637 | authenticatorStream(metadata: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; 638 | databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 639 | databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 640 | databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 641 | databaseUserGet(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 642 | databaseUserGet(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 643 | databaseUserGet(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 644 | databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 645 | databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 646 | databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 647 | databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 648 | databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 649 | databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 650 | databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 651 | databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 652 | databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 653 | databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 654 | databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 655 | databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 656 | redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 657 | redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 658 | redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 659 | redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 660 | redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 661 | redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 662 | } 663 | 664 | export class V1Client extends grpc.Client implements IV1Client { 665 | constructor(address: string, credentials: grpc.ChannelCredentials, options?: object); 666 | public getUptime(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 667 | public getUptime(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 668 | public getUptime(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Uptime) => void): grpc.ClientUnaryCall; 669 | public getVersion(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 670 | public getVersion(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 671 | public getVersion(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Version) => void): grpc.ClientUnaryCall; 672 | public events(request: MurmurRPC_pb.Void, options?: Partial): grpc.ClientReadableStream; 673 | public events(request: MurmurRPC_pb.Void, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 674 | public serverCreate(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 675 | public serverCreate(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 676 | public serverCreate(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 677 | public serverQuery(request: MurmurRPC_pb.Server.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 678 | public serverQuery(request: MurmurRPC_pb.Server.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 679 | public serverQuery(request: MurmurRPC_pb.Server.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server.List) => void): grpc.ClientUnaryCall; 680 | public serverGet(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 681 | public serverGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 682 | public serverGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Server) => void): grpc.ClientUnaryCall; 683 | public serverStart(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 684 | public serverStart(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 685 | public serverStart(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 686 | public serverStop(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 687 | public serverStop(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 688 | public serverStop(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 689 | public serverRemove(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 690 | public serverRemove(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 691 | public serverRemove(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 692 | public serverEvents(request: MurmurRPC_pb.Server, options?: Partial): grpc.ClientReadableStream; 693 | public serverEvents(request: MurmurRPC_pb.Server, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 694 | public contextActionAdd(request: MurmurRPC_pb.ContextAction, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 695 | public contextActionAdd(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 696 | public contextActionAdd(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 697 | public contextActionRemove(request: MurmurRPC_pb.ContextAction, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 698 | public contextActionRemove(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 699 | public contextActionRemove(request: MurmurRPC_pb.ContextAction, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 700 | public contextActionEvents(request: MurmurRPC_pb.ContextAction, options?: Partial): grpc.ClientReadableStream; 701 | public contextActionEvents(request: MurmurRPC_pb.ContextAction, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; 702 | public textMessageSend(request: MurmurRPC_pb.TextMessage, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 703 | public textMessageSend(request: MurmurRPC_pb.TextMessage, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 704 | public textMessageSend(request: MurmurRPC_pb.TextMessage, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 705 | public textMessageFilter(options?: Partial): grpc.ClientDuplexStream; 706 | public textMessageFilter(metadata?: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; 707 | public logQuery(request: MurmurRPC_pb.Log.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 708 | public logQuery(request: MurmurRPC_pb.Log.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 709 | public logQuery(request: MurmurRPC_pb.Log.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Log.List) => void): grpc.ClientUnaryCall; 710 | public configGet(request: MurmurRPC_pb.Server, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 711 | public configGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 712 | public configGet(request: MurmurRPC_pb.Server, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 713 | public configGetField(request: MurmurRPC_pb.Config.Field, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 714 | public configGetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 715 | public configGetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config.Field) => void): grpc.ClientUnaryCall; 716 | public configSetField(request: MurmurRPC_pb.Config.Field, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 717 | public configSetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 718 | public configSetField(request: MurmurRPC_pb.Config.Field, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 719 | public configGetDefault(request: MurmurRPC_pb.Void, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 720 | public configGetDefault(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 721 | public configGetDefault(request: MurmurRPC_pb.Void, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Config) => void): grpc.ClientUnaryCall; 722 | public channelQuery(request: MurmurRPC_pb.Channel.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 723 | public channelQuery(request: MurmurRPC_pb.Channel.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 724 | public channelQuery(request: MurmurRPC_pb.Channel.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel.List) => void): grpc.ClientUnaryCall; 725 | public channelGet(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 726 | public channelGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 727 | public channelGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 728 | public channelAdd(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 729 | public channelAdd(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 730 | public channelAdd(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 731 | public channelRemove(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 732 | public channelRemove(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 733 | public channelRemove(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 734 | public channelUpdate(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 735 | public channelUpdate(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 736 | public channelUpdate(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Channel) => void): grpc.ClientUnaryCall; 737 | public userQuery(request: MurmurRPC_pb.User.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 738 | public userQuery(request: MurmurRPC_pb.User.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 739 | public userQuery(request: MurmurRPC_pb.User.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User.List) => void): grpc.ClientUnaryCall; 740 | public userGet(request: MurmurRPC_pb.User, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 741 | public userGet(request: MurmurRPC_pb.User, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 742 | public userGet(request: MurmurRPC_pb.User, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 743 | public userUpdate(request: MurmurRPC_pb.User, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 744 | public userUpdate(request: MurmurRPC_pb.User, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 745 | public userUpdate(request: MurmurRPC_pb.User, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.User) => void): grpc.ClientUnaryCall; 746 | public userKick(request: MurmurRPC_pb.User.Kick, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 747 | public userKick(request: MurmurRPC_pb.User.Kick, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 748 | public userKick(request: MurmurRPC_pb.User.Kick, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 749 | public treeQuery(request: MurmurRPC_pb.Tree.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 750 | public treeQuery(request: MurmurRPC_pb.Tree.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 751 | public treeQuery(request: MurmurRPC_pb.Tree.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Tree) => void): grpc.ClientUnaryCall; 752 | public bansGet(request: MurmurRPC_pb.Ban.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 753 | public bansGet(request: MurmurRPC_pb.Ban.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 754 | public bansGet(request: MurmurRPC_pb.Ban.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Ban.List) => void): grpc.ClientUnaryCall; 755 | public bansSet(request: MurmurRPC_pb.Ban.List, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 756 | public bansSet(request: MurmurRPC_pb.Ban.List, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 757 | public bansSet(request: MurmurRPC_pb.Ban.List, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 758 | public aCLGet(request: MurmurRPC_pb.Channel, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 759 | public aCLGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 760 | public aCLGet(request: MurmurRPC_pb.Channel, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL.List) => void): grpc.ClientUnaryCall; 761 | public aCLSet(request: MurmurRPC_pb.ACL.List, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 762 | public aCLSet(request: MurmurRPC_pb.ACL.List, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 763 | public aCLSet(request: MurmurRPC_pb.ACL.List, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 764 | public aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 765 | public aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 766 | public aCLGetEffectivePermissions(request: MurmurRPC_pb.ACL.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.ACL) => void): grpc.ClientUnaryCall; 767 | public aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 768 | public aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 769 | public aCLAddTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 770 | public aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 771 | public aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 772 | public aCLRemoveTemporaryGroup(request: MurmurRPC_pb.ACL.TemporaryGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 773 | public authenticatorStream(options?: Partial): grpc.ClientDuplexStream; 774 | public authenticatorStream(metadata?: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; 775 | public databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 776 | public databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 777 | public databaseUserQuery(request: MurmurRPC_pb.DatabaseUser.Query, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser.List) => void): grpc.ClientUnaryCall; 778 | public databaseUserGet(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 779 | public databaseUserGet(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 780 | public databaseUserGet(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 781 | public databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 782 | public databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 783 | public databaseUserUpdate(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 784 | public databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 785 | public databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 786 | public databaseUserRegister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 787 | public databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 788 | public databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 789 | public databaseUserDeregister(request: MurmurRPC_pb.DatabaseUser, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 790 | public databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 791 | public databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 792 | public databaseUserVerify(request: MurmurRPC_pb.DatabaseUser.Verify, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.DatabaseUser) => void): grpc.ClientUnaryCall; 793 | public redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 794 | public redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 795 | public redirectWhisperGroupAdd(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 796 | public redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 797 | public redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 798 | public redirectWhisperGroupRemove(request: MurmurRPC_pb.RedirectWhisperGroup, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: MurmurRPC_pb.Void) => void): grpc.ClientUnaryCall; 799 | } 800 | -------------------------------------------------------------------------------- /lib/MurmurRPC_grpc_pb.js: -------------------------------------------------------------------------------- 1 | // GENERATED CODE -- DO NOT EDIT! 2 | 3 | // Original file comments: 4 | // Copyright 2005-2019 The Mumble Developers. All rights reserved. 5 | // Use of this source code is governed by a BSD-style license 6 | // that can be found in the LICENSE file at the root of the 7 | // Mumble source tree or at . 8 | // 9 | 'use strict'; 10 | var MurmurRPC_pb = require('./MurmurRPC_pb.js'); 11 | 12 | function serialize_MurmurRPC_ACL(arg) { 13 | if (!(arg instanceof MurmurRPC_pb.ACL)) { 14 | throw new Error('Expected argument of type MurmurRPC.ACL'); 15 | } 16 | return Buffer.from(arg.serializeBinary()); 17 | } 18 | 19 | function deserialize_MurmurRPC_ACL(buffer_arg) { 20 | return MurmurRPC_pb.ACL.deserializeBinary(new Uint8Array(buffer_arg)); 21 | } 22 | 23 | function serialize_MurmurRPC_ACL_List(arg) { 24 | if (!(arg instanceof MurmurRPC_pb.ACL.List)) { 25 | throw new Error('Expected argument of type MurmurRPC.ACL.List'); 26 | } 27 | return Buffer.from(arg.serializeBinary()); 28 | } 29 | 30 | function deserialize_MurmurRPC_ACL_List(buffer_arg) { 31 | return MurmurRPC_pb.ACL.List.deserializeBinary(new Uint8Array(buffer_arg)); 32 | } 33 | 34 | function serialize_MurmurRPC_ACL_Query(arg) { 35 | if (!(arg instanceof MurmurRPC_pb.ACL.Query)) { 36 | throw new Error('Expected argument of type MurmurRPC.ACL.Query'); 37 | } 38 | return Buffer.from(arg.serializeBinary()); 39 | } 40 | 41 | function deserialize_MurmurRPC_ACL_Query(buffer_arg) { 42 | return MurmurRPC_pb.ACL.Query.deserializeBinary(new Uint8Array(buffer_arg)); 43 | } 44 | 45 | function serialize_MurmurRPC_ACL_TemporaryGroup(arg) { 46 | if (!(arg instanceof MurmurRPC_pb.ACL.TemporaryGroup)) { 47 | throw new Error('Expected argument of type MurmurRPC.ACL.TemporaryGroup'); 48 | } 49 | return Buffer.from(arg.serializeBinary()); 50 | } 51 | 52 | function deserialize_MurmurRPC_ACL_TemporaryGroup(buffer_arg) { 53 | return MurmurRPC_pb.ACL.TemporaryGroup.deserializeBinary(new Uint8Array(buffer_arg)); 54 | } 55 | 56 | function serialize_MurmurRPC_Authenticator_Request(arg) { 57 | if (!(arg instanceof MurmurRPC_pb.Authenticator.Request)) { 58 | throw new Error('Expected argument of type MurmurRPC.Authenticator.Request'); 59 | } 60 | return Buffer.from(arg.serializeBinary()); 61 | } 62 | 63 | function deserialize_MurmurRPC_Authenticator_Request(buffer_arg) { 64 | return MurmurRPC_pb.Authenticator.Request.deserializeBinary(new Uint8Array(buffer_arg)); 65 | } 66 | 67 | function serialize_MurmurRPC_Authenticator_Response(arg) { 68 | if (!(arg instanceof MurmurRPC_pb.Authenticator.Response)) { 69 | throw new Error('Expected argument of type MurmurRPC.Authenticator.Response'); 70 | } 71 | return Buffer.from(arg.serializeBinary()); 72 | } 73 | 74 | function deserialize_MurmurRPC_Authenticator_Response(buffer_arg) { 75 | return MurmurRPC_pb.Authenticator.Response.deserializeBinary(new Uint8Array(buffer_arg)); 76 | } 77 | 78 | function serialize_MurmurRPC_Ban_List(arg) { 79 | if (!(arg instanceof MurmurRPC_pb.Ban.List)) { 80 | throw new Error('Expected argument of type MurmurRPC.Ban.List'); 81 | } 82 | return Buffer.from(arg.serializeBinary()); 83 | } 84 | 85 | function deserialize_MurmurRPC_Ban_List(buffer_arg) { 86 | return MurmurRPC_pb.Ban.List.deserializeBinary(new Uint8Array(buffer_arg)); 87 | } 88 | 89 | function serialize_MurmurRPC_Ban_Query(arg) { 90 | if (!(arg instanceof MurmurRPC_pb.Ban.Query)) { 91 | throw new Error('Expected argument of type MurmurRPC.Ban.Query'); 92 | } 93 | return Buffer.from(arg.serializeBinary()); 94 | } 95 | 96 | function deserialize_MurmurRPC_Ban_Query(buffer_arg) { 97 | return MurmurRPC_pb.Ban.Query.deserializeBinary(new Uint8Array(buffer_arg)); 98 | } 99 | 100 | function serialize_MurmurRPC_Channel(arg) { 101 | if (!(arg instanceof MurmurRPC_pb.Channel)) { 102 | throw new Error('Expected argument of type MurmurRPC.Channel'); 103 | } 104 | return Buffer.from(arg.serializeBinary()); 105 | } 106 | 107 | function deserialize_MurmurRPC_Channel(buffer_arg) { 108 | return MurmurRPC_pb.Channel.deserializeBinary(new Uint8Array(buffer_arg)); 109 | } 110 | 111 | function serialize_MurmurRPC_Channel_List(arg) { 112 | if (!(arg instanceof MurmurRPC_pb.Channel.List)) { 113 | throw new Error('Expected argument of type MurmurRPC.Channel.List'); 114 | } 115 | return Buffer.from(arg.serializeBinary()); 116 | } 117 | 118 | function deserialize_MurmurRPC_Channel_List(buffer_arg) { 119 | return MurmurRPC_pb.Channel.List.deserializeBinary(new Uint8Array(buffer_arg)); 120 | } 121 | 122 | function serialize_MurmurRPC_Channel_Query(arg) { 123 | if (!(arg instanceof MurmurRPC_pb.Channel.Query)) { 124 | throw new Error('Expected argument of type MurmurRPC.Channel.Query'); 125 | } 126 | return Buffer.from(arg.serializeBinary()); 127 | } 128 | 129 | function deserialize_MurmurRPC_Channel_Query(buffer_arg) { 130 | return MurmurRPC_pb.Channel.Query.deserializeBinary(new Uint8Array(buffer_arg)); 131 | } 132 | 133 | function serialize_MurmurRPC_Config(arg) { 134 | if (!(arg instanceof MurmurRPC_pb.Config)) { 135 | throw new Error('Expected argument of type MurmurRPC.Config'); 136 | } 137 | return Buffer.from(arg.serializeBinary()); 138 | } 139 | 140 | function deserialize_MurmurRPC_Config(buffer_arg) { 141 | return MurmurRPC_pb.Config.deserializeBinary(new Uint8Array(buffer_arg)); 142 | } 143 | 144 | function serialize_MurmurRPC_Config_Field(arg) { 145 | if (!(arg instanceof MurmurRPC_pb.Config.Field)) { 146 | throw new Error('Expected argument of type MurmurRPC.Config.Field'); 147 | } 148 | return Buffer.from(arg.serializeBinary()); 149 | } 150 | 151 | function deserialize_MurmurRPC_Config_Field(buffer_arg) { 152 | return MurmurRPC_pb.Config.Field.deserializeBinary(new Uint8Array(buffer_arg)); 153 | } 154 | 155 | function serialize_MurmurRPC_ContextAction(arg) { 156 | if (!(arg instanceof MurmurRPC_pb.ContextAction)) { 157 | throw new Error('Expected argument of type MurmurRPC.ContextAction'); 158 | } 159 | return Buffer.from(arg.serializeBinary()); 160 | } 161 | 162 | function deserialize_MurmurRPC_ContextAction(buffer_arg) { 163 | return MurmurRPC_pb.ContextAction.deserializeBinary(new Uint8Array(buffer_arg)); 164 | } 165 | 166 | function serialize_MurmurRPC_DatabaseUser(arg) { 167 | if (!(arg instanceof MurmurRPC_pb.DatabaseUser)) { 168 | throw new Error('Expected argument of type MurmurRPC.DatabaseUser'); 169 | } 170 | return Buffer.from(arg.serializeBinary()); 171 | } 172 | 173 | function deserialize_MurmurRPC_DatabaseUser(buffer_arg) { 174 | return MurmurRPC_pb.DatabaseUser.deserializeBinary(new Uint8Array(buffer_arg)); 175 | } 176 | 177 | function serialize_MurmurRPC_DatabaseUser_List(arg) { 178 | if (!(arg instanceof MurmurRPC_pb.DatabaseUser.List)) { 179 | throw new Error('Expected argument of type MurmurRPC.DatabaseUser.List'); 180 | } 181 | return Buffer.from(arg.serializeBinary()); 182 | } 183 | 184 | function deserialize_MurmurRPC_DatabaseUser_List(buffer_arg) { 185 | return MurmurRPC_pb.DatabaseUser.List.deserializeBinary(new Uint8Array(buffer_arg)); 186 | } 187 | 188 | function serialize_MurmurRPC_DatabaseUser_Query(arg) { 189 | if (!(arg instanceof MurmurRPC_pb.DatabaseUser.Query)) { 190 | throw new Error('Expected argument of type MurmurRPC.DatabaseUser.Query'); 191 | } 192 | return Buffer.from(arg.serializeBinary()); 193 | } 194 | 195 | function deserialize_MurmurRPC_DatabaseUser_Query(buffer_arg) { 196 | return MurmurRPC_pb.DatabaseUser.Query.deserializeBinary(new Uint8Array(buffer_arg)); 197 | } 198 | 199 | function serialize_MurmurRPC_DatabaseUser_Verify(arg) { 200 | if (!(arg instanceof MurmurRPC_pb.DatabaseUser.Verify)) { 201 | throw new Error('Expected argument of type MurmurRPC.DatabaseUser.Verify'); 202 | } 203 | return Buffer.from(arg.serializeBinary()); 204 | } 205 | 206 | function deserialize_MurmurRPC_DatabaseUser_Verify(buffer_arg) { 207 | return MurmurRPC_pb.DatabaseUser.Verify.deserializeBinary(new Uint8Array(buffer_arg)); 208 | } 209 | 210 | function serialize_MurmurRPC_Event(arg) { 211 | if (!(arg instanceof MurmurRPC_pb.Event)) { 212 | throw new Error('Expected argument of type MurmurRPC.Event'); 213 | } 214 | return Buffer.from(arg.serializeBinary()); 215 | } 216 | 217 | function deserialize_MurmurRPC_Event(buffer_arg) { 218 | return MurmurRPC_pb.Event.deserializeBinary(new Uint8Array(buffer_arg)); 219 | } 220 | 221 | function serialize_MurmurRPC_Log_List(arg) { 222 | if (!(arg instanceof MurmurRPC_pb.Log.List)) { 223 | throw new Error('Expected argument of type MurmurRPC.Log.List'); 224 | } 225 | return Buffer.from(arg.serializeBinary()); 226 | } 227 | 228 | function deserialize_MurmurRPC_Log_List(buffer_arg) { 229 | return MurmurRPC_pb.Log.List.deserializeBinary(new Uint8Array(buffer_arg)); 230 | } 231 | 232 | function serialize_MurmurRPC_Log_Query(arg) { 233 | if (!(arg instanceof MurmurRPC_pb.Log.Query)) { 234 | throw new Error('Expected argument of type MurmurRPC.Log.Query'); 235 | } 236 | return Buffer.from(arg.serializeBinary()); 237 | } 238 | 239 | function deserialize_MurmurRPC_Log_Query(buffer_arg) { 240 | return MurmurRPC_pb.Log.Query.deserializeBinary(new Uint8Array(buffer_arg)); 241 | } 242 | 243 | function serialize_MurmurRPC_RedirectWhisperGroup(arg) { 244 | if (!(arg instanceof MurmurRPC_pb.RedirectWhisperGroup)) { 245 | throw new Error('Expected argument of type MurmurRPC.RedirectWhisperGroup'); 246 | } 247 | return Buffer.from(arg.serializeBinary()); 248 | } 249 | 250 | function deserialize_MurmurRPC_RedirectWhisperGroup(buffer_arg) { 251 | return MurmurRPC_pb.RedirectWhisperGroup.deserializeBinary(new Uint8Array(buffer_arg)); 252 | } 253 | 254 | function serialize_MurmurRPC_Server(arg) { 255 | if (!(arg instanceof MurmurRPC_pb.Server)) { 256 | throw new Error('Expected argument of type MurmurRPC.Server'); 257 | } 258 | return Buffer.from(arg.serializeBinary()); 259 | } 260 | 261 | function deserialize_MurmurRPC_Server(buffer_arg) { 262 | return MurmurRPC_pb.Server.deserializeBinary(new Uint8Array(buffer_arg)); 263 | } 264 | 265 | function serialize_MurmurRPC_Server_Event(arg) { 266 | if (!(arg instanceof MurmurRPC_pb.Server.Event)) { 267 | throw new Error('Expected argument of type MurmurRPC.Server.Event'); 268 | } 269 | return Buffer.from(arg.serializeBinary()); 270 | } 271 | 272 | function deserialize_MurmurRPC_Server_Event(buffer_arg) { 273 | return MurmurRPC_pb.Server.Event.deserializeBinary(new Uint8Array(buffer_arg)); 274 | } 275 | 276 | function serialize_MurmurRPC_Server_List(arg) { 277 | if (!(arg instanceof MurmurRPC_pb.Server.List)) { 278 | throw new Error('Expected argument of type MurmurRPC.Server.List'); 279 | } 280 | return Buffer.from(arg.serializeBinary()); 281 | } 282 | 283 | function deserialize_MurmurRPC_Server_List(buffer_arg) { 284 | return MurmurRPC_pb.Server.List.deserializeBinary(new Uint8Array(buffer_arg)); 285 | } 286 | 287 | function serialize_MurmurRPC_Server_Query(arg) { 288 | if (!(arg instanceof MurmurRPC_pb.Server.Query)) { 289 | throw new Error('Expected argument of type MurmurRPC.Server.Query'); 290 | } 291 | return Buffer.from(arg.serializeBinary()); 292 | } 293 | 294 | function deserialize_MurmurRPC_Server_Query(buffer_arg) { 295 | return MurmurRPC_pb.Server.Query.deserializeBinary(new Uint8Array(buffer_arg)); 296 | } 297 | 298 | function serialize_MurmurRPC_TextMessage(arg) { 299 | if (!(arg instanceof MurmurRPC_pb.TextMessage)) { 300 | throw new Error('Expected argument of type MurmurRPC.TextMessage'); 301 | } 302 | return Buffer.from(arg.serializeBinary()); 303 | } 304 | 305 | function deserialize_MurmurRPC_TextMessage(buffer_arg) { 306 | return MurmurRPC_pb.TextMessage.deserializeBinary(new Uint8Array(buffer_arg)); 307 | } 308 | 309 | function serialize_MurmurRPC_TextMessage_Filter(arg) { 310 | if (!(arg instanceof MurmurRPC_pb.TextMessage.Filter)) { 311 | throw new Error('Expected argument of type MurmurRPC.TextMessage.Filter'); 312 | } 313 | return Buffer.from(arg.serializeBinary()); 314 | } 315 | 316 | function deserialize_MurmurRPC_TextMessage_Filter(buffer_arg) { 317 | return MurmurRPC_pb.TextMessage.Filter.deserializeBinary(new Uint8Array(buffer_arg)); 318 | } 319 | 320 | function serialize_MurmurRPC_Tree(arg) { 321 | if (!(arg instanceof MurmurRPC_pb.Tree)) { 322 | throw new Error('Expected argument of type MurmurRPC.Tree'); 323 | } 324 | return Buffer.from(arg.serializeBinary()); 325 | } 326 | 327 | function deserialize_MurmurRPC_Tree(buffer_arg) { 328 | return MurmurRPC_pb.Tree.deserializeBinary(new Uint8Array(buffer_arg)); 329 | } 330 | 331 | function serialize_MurmurRPC_Tree_Query(arg) { 332 | if (!(arg instanceof MurmurRPC_pb.Tree.Query)) { 333 | throw new Error('Expected argument of type MurmurRPC.Tree.Query'); 334 | } 335 | return Buffer.from(arg.serializeBinary()); 336 | } 337 | 338 | function deserialize_MurmurRPC_Tree_Query(buffer_arg) { 339 | return MurmurRPC_pb.Tree.Query.deserializeBinary(new Uint8Array(buffer_arg)); 340 | } 341 | 342 | function serialize_MurmurRPC_Uptime(arg) { 343 | if (!(arg instanceof MurmurRPC_pb.Uptime)) { 344 | throw new Error('Expected argument of type MurmurRPC.Uptime'); 345 | } 346 | return Buffer.from(arg.serializeBinary()); 347 | } 348 | 349 | function deserialize_MurmurRPC_Uptime(buffer_arg) { 350 | return MurmurRPC_pb.Uptime.deserializeBinary(new Uint8Array(buffer_arg)); 351 | } 352 | 353 | function serialize_MurmurRPC_User(arg) { 354 | if (!(arg instanceof MurmurRPC_pb.User)) { 355 | throw new Error('Expected argument of type MurmurRPC.User'); 356 | } 357 | return Buffer.from(arg.serializeBinary()); 358 | } 359 | 360 | function deserialize_MurmurRPC_User(buffer_arg) { 361 | return MurmurRPC_pb.User.deserializeBinary(new Uint8Array(buffer_arg)); 362 | } 363 | 364 | function serialize_MurmurRPC_User_Kick(arg) { 365 | if (!(arg instanceof MurmurRPC_pb.User.Kick)) { 366 | throw new Error('Expected argument of type MurmurRPC.User.Kick'); 367 | } 368 | return Buffer.from(arg.serializeBinary()); 369 | } 370 | 371 | function deserialize_MurmurRPC_User_Kick(buffer_arg) { 372 | return MurmurRPC_pb.User.Kick.deserializeBinary(new Uint8Array(buffer_arg)); 373 | } 374 | 375 | function serialize_MurmurRPC_User_List(arg) { 376 | if (!(arg instanceof MurmurRPC_pb.User.List)) { 377 | throw new Error('Expected argument of type MurmurRPC.User.List'); 378 | } 379 | return Buffer.from(arg.serializeBinary()); 380 | } 381 | 382 | function deserialize_MurmurRPC_User_List(buffer_arg) { 383 | return MurmurRPC_pb.User.List.deserializeBinary(new Uint8Array(buffer_arg)); 384 | } 385 | 386 | function serialize_MurmurRPC_User_Query(arg) { 387 | if (!(arg instanceof MurmurRPC_pb.User.Query)) { 388 | throw new Error('Expected argument of type MurmurRPC.User.Query'); 389 | } 390 | return Buffer.from(arg.serializeBinary()); 391 | } 392 | 393 | function deserialize_MurmurRPC_User_Query(buffer_arg) { 394 | return MurmurRPC_pb.User.Query.deserializeBinary(new Uint8Array(buffer_arg)); 395 | } 396 | 397 | function serialize_MurmurRPC_Version(arg) { 398 | if (!(arg instanceof MurmurRPC_pb.Version)) { 399 | throw new Error('Expected argument of type MurmurRPC.Version'); 400 | } 401 | return Buffer.from(arg.serializeBinary()); 402 | } 403 | 404 | function deserialize_MurmurRPC_Version(buffer_arg) { 405 | return MurmurRPC_pb.Version.deserializeBinary(new Uint8Array(buffer_arg)); 406 | } 407 | 408 | function serialize_MurmurRPC_Void(arg) { 409 | if (!(arg instanceof MurmurRPC_pb.Void)) { 410 | throw new Error('Expected argument of type MurmurRPC.Void'); 411 | } 412 | return Buffer.from(arg.serializeBinary()); 413 | } 414 | 415 | function deserialize_MurmurRPC_Void(buffer_arg) { 416 | return MurmurRPC_pb.Void.deserializeBinary(new Uint8Array(buffer_arg)); 417 | } 418 | 419 | 420 | var V1Service = exports['MurmurRPC.V1'] = { 421 | // GetUptime returns murmur's uptime. 422 | getUptime: { 423 | path: '/MurmurRPC.V1/GetUptime', 424 | requestStream: false, 425 | responseStream: false, 426 | requestType: MurmurRPC_pb.Void, 427 | responseType: MurmurRPC_pb.Uptime, 428 | requestSerialize: serialize_MurmurRPC_Void, 429 | requestDeserialize: deserialize_MurmurRPC_Void, 430 | responseSerialize: serialize_MurmurRPC_Uptime, 431 | responseDeserialize: deserialize_MurmurRPC_Uptime, 432 | }, 433 | // GetVersion returns murmur's version. 434 | getVersion: { 435 | path: '/MurmurRPC.V1/GetVersion', 436 | requestStream: false, 437 | responseStream: false, 438 | requestType: MurmurRPC_pb.Void, 439 | responseType: MurmurRPC_pb.Version, 440 | requestSerialize: serialize_MurmurRPC_Void, 441 | requestDeserialize: deserialize_MurmurRPC_Void, 442 | responseSerialize: serialize_MurmurRPC_Version, 443 | responseDeserialize: deserialize_MurmurRPC_Version, 444 | }, 445 | // Events returns a stream of murmur events. 446 | events: { 447 | path: '/MurmurRPC.V1/Events', 448 | requestStream: false, 449 | responseStream: true, 450 | requestType: MurmurRPC_pb.Void, 451 | responseType: MurmurRPC_pb.Event, 452 | requestSerialize: serialize_MurmurRPC_Void, 453 | requestDeserialize: deserialize_MurmurRPC_Void, 454 | responseSerialize: serialize_MurmurRPC_Event, 455 | responseDeserialize: deserialize_MurmurRPC_Event, 456 | }, 457 | // 458 | // Servers 459 | // 460 | // 461 | // ServerCreate creates a new virtual server. The returned server object 462 | // contains the newly created server's ID. 463 | serverCreate: { 464 | path: '/MurmurRPC.V1/ServerCreate', 465 | requestStream: false, 466 | responseStream: false, 467 | requestType: MurmurRPC_pb.Void, 468 | responseType: MurmurRPC_pb.Server, 469 | requestSerialize: serialize_MurmurRPC_Void, 470 | requestDeserialize: deserialize_MurmurRPC_Void, 471 | responseSerialize: serialize_MurmurRPC_Server, 472 | responseDeserialize: deserialize_MurmurRPC_Server, 473 | }, 474 | // ServerQuery returns a list of servers that match the given query. 475 | serverQuery: { 476 | path: '/MurmurRPC.V1/ServerQuery', 477 | requestStream: false, 478 | responseStream: false, 479 | requestType: MurmurRPC_pb.Server.Query, 480 | responseType: MurmurRPC_pb.Server.List, 481 | requestSerialize: serialize_MurmurRPC_Server_Query, 482 | requestDeserialize: deserialize_MurmurRPC_Server_Query, 483 | responseSerialize: serialize_MurmurRPC_Server_List, 484 | responseDeserialize: deserialize_MurmurRPC_Server_List, 485 | }, 486 | // ServerGet returns information about the given server. 487 | serverGet: { 488 | path: '/MurmurRPC.V1/ServerGet', 489 | requestStream: false, 490 | responseStream: false, 491 | requestType: MurmurRPC_pb.Server, 492 | responseType: MurmurRPC_pb.Server, 493 | requestSerialize: serialize_MurmurRPC_Server, 494 | requestDeserialize: deserialize_MurmurRPC_Server, 495 | responseSerialize: serialize_MurmurRPC_Server, 496 | responseDeserialize: deserialize_MurmurRPC_Server, 497 | }, 498 | // ServerStart starts the given stopped server. 499 | serverStart: { 500 | path: '/MurmurRPC.V1/ServerStart', 501 | requestStream: false, 502 | responseStream: false, 503 | requestType: MurmurRPC_pb.Server, 504 | responseType: MurmurRPC_pb.Void, 505 | requestSerialize: serialize_MurmurRPC_Server, 506 | requestDeserialize: deserialize_MurmurRPC_Server, 507 | responseSerialize: serialize_MurmurRPC_Void, 508 | responseDeserialize: deserialize_MurmurRPC_Void, 509 | }, 510 | // ServerStop stops the given virtual server. 511 | serverStop: { 512 | path: '/MurmurRPC.V1/ServerStop', 513 | requestStream: false, 514 | responseStream: false, 515 | requestType: MurmurRPC_pb.Server, 516 | responseType: MurmurRPC_pb.Void, 517 | requestSerialize: serialize_MurmurRPC_Server, 518 | requestDeserialize: deserialize_MurmurRPC_Server, 519 | responseSerialize: serialize_MurmurRPC_Void, 520 | responseDeserialize: deserialize_MurmurRPC_Void, 521 | }, 522 | // ServerRemove removes the given virtual server and its configuration. 523 | serverRemove: { 524 | path: '/MurmurRPC.V1/ServerRemove', 525 | requestStream: false, 526 | responseStream: false, 527 | requestType: MurmurRPC_pb.Server, 528 | responseType: MurmurRPC_pb.Void, 529 | requestSerialize: serialize_MurmurRPC_Server, 530 | requestDeserialize: deserialize_MurmurRPC_Server, 531 | responseSerialize: serialize_MurmurRPC_Void, 532 | responseDeserialize: deserialize_MurmurRPC_Void, 533 | }, 534 | // ServerEvents returns a stream of events that happen on the given server. 535 | serverEvents: { 536 | path: '/MurmurRPC.V1/ServerEvents', 537 | requestStream: false, 538 | responseStream: true, 539 | requestType: MurmurRPC_pb.Server, 540 | responseType: MurmurRPC_pb.Server.Event, 541 | requestSerialize: serialize_MurmurRPC_Server, 542 | requestDeserialize: deserialize_MurmurRPC_Server, 543 | responseSerialize: serialize_MurmurRPC_Server_Event, 544 | responseDeserialize: deserialize_MurmurRPC_Server_Event, 545 | }, 546 | // 547 | // ContextActions 548 | // 549 | // 550 | // ContextActionAdd adds a context action to the given user's client. The 551 | // following ContextAction fields must be set: 552 | // context, action, text, and user. 553 | // 554 | // Added context actions are valid until: 555 | // - The context action is removed with ContextActionRemove, or 556 | // - The user disconnects from the server, or 557 | // - The server stops. 558 | contextActionAdd: { 559 | path: '/MurmurRPC.V1/ContextActionAdd', 560 | requestStream: false, 561 | responseStream: false, 562 | requestType: MurmurRPC_pb.ContextAction, 563 | responseType: MurmurRPC_pb.Void, 564 | requestSerialize: serialize_MurmurRPC_ContextAction, 565 | requestDeserialize: deserialize_MurmurRPC_ContextAction, 566 | responseSerialize: serialize_MurmurRPC_Void, 567 | responseDeserialize: deserialize_MurmurRPC_Void, 568 | }, 569 | // ContextActionRemove removes a context action from the given user's client. 570 | // The following ContextAction must be set: 571 | // action 572 | // If no user is given, the context action is removed from all users. 573 | contextActionRemove: { 574 | path: '/MurmurRPC.V1/ContextActionRemove', 575 | requestStream: false, 576 | responseStream: false, 577 | requestType: MurmurRPC_pb.ContextAction, 578 | responseType: MurmurRPC_pb.Void, 579 | requestSerialize: serialize_MurmurRPC_ContextAction, 580 | requestDeserialize: deserialize_MurmurRPC_ContextAction, 581 | responseSerialize: serialize_MurmurRPC_Void, 582 | responseDeserialize: deserialize_MurmurRPC_Void, 583 | }, 584 | // ContextActionEvents returns a stream of context action events that are 585 | // triggered by users. 586 | contextActionEvents: { 587 | path: '/MurmurRPC.V1/ContextActionEvents', 588 | requestStream: false, 589 | responseStream: true, 590 | requestType: MurmurRPC_pb.ContextAction, 591 | responseType: MurmurRPC_pb.ContextAction, 592 | requestSerialize: serialize_MurmurRPC_ContextAction, 593 | requestDeserialize: deserialize_MurmurRPC_ContextAction, 594 | responseSerialize: serialize_MurmurRPC_ContextAction, 595 | responseDeserialize: deserialize_MurmurRPC_ContextAction, 596 | }, 597 | // 598 | // TextMessage 599 | // 600 | // 601 | // TextMessageSend sends the given TextMessage to the server. 602 | // 603 | // If no users, channels, or trees are added to the TextMessage, the message 604 | // will be broadcast the entire server. Otherwise, the message will be 605 | // targeted to the specified users, channels, and trees. 606 | textMessageSend: { 607 | path: '/MurmurRPC.V1/TextMessageSend', 608 | requestStream: false, 609 | responseStream: false, 610 | requestType: MurmurRPC_pb.TextMessage, 611 | responseType: MurmurRPC_pb.Void, 612 | requestSerialize: serialize_MurmurRPC_TextMessage, 613 | requestDeserialize: deserialize_MurmurRPC_TextMessage, 614 | responseSerialize: serialize_MurmurRPC_Void, 615 | responseDeserialize: deserialize_MurmurRPC_Void, 616 | }, 617 | // TextMessageFilter filters text messages on a given server. 618 | // TextMessageFilter filters text messages for a given server. 619 | // 620 | // When a filter stream is active, text messages sent from users to the 621 | // server are sent over the stream. The RPC client then sends a message back 622 | // on the same stream, containing an action: whether the message should be 623 | // accepted, rejected, or dropped. 624 | // 625 | // To activate the filter stream, an initial TextMessage.Filter message must 626 | // be sent that contains the server on which the filter will be active. 627 | textMessageFilter: { 628 | path: '/MurmurRPC.V1/TextMessageFilter', 629 | requestStream: true, 630 | responseStream: true, 631 | requestType: MurmurRPC_pb.TextMessage.Filter, 632 | responseType: MurmurRPC_pb.TextMessage.Filter, 633 | requestSerialize: serialize_MurmurRPC_TextMessage_Filter, 634 | requestDeserialize: deserialize_MurmurRPC_TextMessage_Filter, 635 | responseSerialize: serialize_MurmurRPC_TextMessage_Filter, 636 | responseDeserialize: deserialize_MurmurRPC_TextMessage_Filter, 637 | }, 638 | // 639 | // Logs 640 | // 641 | // 642 | // LogQuery returns a list of log entries from the given server. 643 | // 644 | // To get the total number of log entries, omit min and/or max from the 645 | // query. 646 | logQuery: { 647 | path: '/MurmurRPC.V1/LogQuery', 648 | requestStream: false, 649 | responseStream: false, 650 | requestType: MurmurRPC_pb.Log.Query, 651 | responseType: MurmurRPC_pb.Log.List, 652 | requestSerialize: serialize_MurmurRPC_Log_Query, 653 | requestDeserialize: deserialize_MurmurRPC_Log_Query, 654 | responseSerialize: serialize_MurmurRPC_Log_List, 655 | responseDeserialize: deserialize_MurmurRPC_Log_List, 656 | }, 657 | // 658 | // Config 659 | // 660 | // 661 | // ConfigGet returns the explicitly set configuration for the given server. 662 | configGet: { 663 | path: '/MurmurRPC.V1/ConfigGet', 664 | requestStream: false, 665 | responseStream: false, 666 | requestType: MurmurRPC_pb.Server, 667 | responseType: MurmurRPC_pb.Config, 668 | requestSerialize: serialize_MurmurRPC_Server, 669 | requestDeserialize: deserialize_MurmurRPC_Server, 670 | responseSerialize: serialize_MurmurRPC_Config, 671 | responseDeserialize: deserialize_MurmurRPC_Config, 672 | }, 673 | // ConfigGetField returns the configuration value for the given key. 674 | configGetField: { 675 | path: '/MurmurRPC.V1/ConfigGetField', 676 | requestStream: false, 677 | responseStream: false, 678 | requestType: MurmurRPC_pb.Config.Field, 679 | responseType: MurmurRPC_pb.Config.Field, 680 | requestSerialize: serialize_MurmurRPC_Config_Field, 681 | requestDeserialize: deserialize_MurmurRPC_Config_Field, 682 | responseSerialize: serialize_MurmurRPC_Config_Field, 683 | responseDeserialize: deserialize_MurmurRPC_Config_Field, 684 | }, 685 | // ConfigSetField sets the configuration value to the given value. 686 | configSetField: { 687 | path: '/MurmurRPC.V1/ConfigSetField', 688 | requestStream: false, 689 | responseStream: false, 690 | requestType: MurmurRPC_pb.Config.Field, 691 | responseType: MurmurRPC_pb.Void, 692 | requestSerialize: serialize_MurmurRPC_Config_Field, 693 | requestDeserialize: deserialize_MurmurRPC_Config_Field, 694 | responseSerialize: serialize_MurmurRPC_Void, 695 | responseDeserialize: deserialize_MurmurRPC_Void, 696 | }, 697 | // ConfigGetDefault returns the default server configuration. 698 | configGetDefault: { 699 | path: '/MurmurRPC.V1/ConfigGetDefault', 700 | requestStream: false, 701 | responseStream: false, 702 | requestType: MurmurRPC_pb.Void, 703 | responseType: MurmurRPC_pb.Config, 704 | requestSerialize: serialize_MurmurRPC_Void, 705 | requestDeserialize: deserialize_MurmurRPC_Void, 706 | responseSerialize: serialize_MurmurRPC_Config, 707 | responseDeserialize: deserialize_MurmurRPC_Config, 708 | }, 709 | // 710 | // Channels 711 | // 712 | // 713 | // ChannelQuery returns a list of channels that match the given query. 714 | channelQuery: { 715 | path: '/MurmurRPC.V1/ChannelQuery', 716 | requestStream: false, 717 | responseStream: false, 718 | requestType: MurmurRPC_pb.Channel.Query, 719 | responseType: MurmurRPC_pb.Channel.List, 720 | requestSerialize: serialize_MurmurRPC_Channel_Query, 721 | requestDeserialize: deserialize_MurmurRPC_Channel_Query, 722 | responseSerialize: serialize_MurmurRPC_Channel_List, 723 | responseDeserialize: deserialize_MurmurRPC_Channel_List, 724 | }, 725 | // ChannelGet returns the channel with the given ID. 726 | channelGet: { 727 | path: '/MurmurRPC.V1/ChannelGet', 728 | requestStream: false, 729 | responseStream: false, 730 | requestType: MurmurRPC_pb.Channel, 731 | responseType: MurmurRPC_pb.Channel, 732 | requestSerialize: serialize_MurmurRPC_Channel, 733 | requestDeserialize: deserialize_MurmurRPC_Channel, 734 | responseSerialize: serialize_MurmurRPC_Channel, 735 | responseDeserialize: deserialize_MurmurRPC_Channel, 736 | }, 737 | // ChannelAdd adds the channel to the given server. The parent and name of 738 | // the channel must be set. 739 | channelAdd: { 740 | path: '/MurmurRPC.V1/ChannelAdd', 741 | requestStream: false, 742 | responseStream: false, 743 | requestType: MurmurRPC_pb.Channel, 744 | responseType: MurmurRPC_pb.Channel, 745 | requestSerialize: serialize_MurmurRPC_Channel, 746 | requestDeserialize: deserialize_MurmurRPC_Channel, 747 | responseSerialize: serialize_MurmurRPC_Channel, 748 | responseDeserialize: deserialize_MurmurRPC_Channel, 749 | }, 750 | // ChannelRemove removes the given channel from the server. 751 | channelRemove: { 752 | path: '/MurmurRPC.V1/ChannelRemove', 753 | requestStream: false, 754 | responseStream: false, 755 | requestType: MurmurRPC_pb.Channel, 756 | responseType: MurmurRPC_pb.Void, 757 | requestSerialize: serialize_MurmurRPC_Channel, 758 | requestDeserialize: deserialize_MurmurRPC_Channel, 759 | responseSerialize: serialize_MurmurRPC_Void, 760 | responseDeserialize: deserialize_MurmurRPC_Void, 761 | }, 762 | // ChannelUpdate updates the given channel's attributes. Only the fields that 763 | // are set will be updated. 764 | channelUpdate: { 765 | path: '/MurmurRPC.V1/ChannelUpdate', 766 | requestStream: false, 767 | responseStream: false, 768 | requestType: MurmurRPC_pb.Channel, 769 | responseType: MurmurRPC_pb.Channel, 770 | requestSerialize: serialize_MurmurRPC_Channel, 771 | requestDeserialize: deserialize_MurmurRPC_Channel, 772 | responseSerialize: serialize_MurmurRPC_Channel, 773 | responseDeserialize: deserialize_MurmurRPC_Channel, 774 | }, 775 | // 776 | // Users 777 | // 778 | // 779 | // UserQuery returns a list of connected users who match the given query. 780 | userQuery: { 781 | path: '/MurmurRPC.V1/UserQuery', 782 | requestStream: false, 783 | responseStream: false, 784 | requestType: MurmurRPC_pb.User.Query, 785 | responseType: MurmurRPC_pb.User.List, 786 | requestSerialize: serialize_MurmurRPC_User_Query, 787 | requestDeserialize: deserialize_MurmurRPC_User_Query, 788 | responseSerialize: serialize_MurmurRPC_User_List, 789 | responseDeserialize: deserialize_MurmurRPC_User_List, 790 | }, 791 | // UserGet returns information on the connected user, given by the user's 792 | // session or name. 793 | userGet: { 794 | path: '/MurmurRPC.V1/UserGet', 795 | requestStream: false, 796 | responseStream: false, 797 | requestType: MurmurRPC_pb.User, 798 | responseType: MurmurRPC_pb.User, 799 | requestSerialize: serialize_MurmurRPC_User, 800 | requestDeserialize: deserialize_MurmurRPC_User, 801 | responseSerialize: serialize_MurmurRPC_User, 802 | responseDeserialize: deserialize_MurmurRPC_User, 803 | }, 804 | // UserUpdate changes the given user's state. Only the following fields can 805 | // be changed: 806 | // name, mute, deaf, suppress, priority_speaker, channel, comment. 807 | userUpdate: { 808 | path: '/MurmurRPC.V1/UserUpdate', 809 | requestStream: false, 810 | responseStream: false, 811 | requestType: MurmurRPC_pb.User, 812 | responseType: MurmurRPC_pb.User, 813 | requestSerialize: serialize_MurmurRPC_User, 814 | requestDeserialize: deserialize_MurmurRPC_User, 815 | responseSerialize: serialize_MurmurRPC_User, 816 | responseDeserialize: deserialize_MurmurRPC_User, 817 | }, 818 | // UserKick kicks the user from the server. 819 | userKick: { 820 | path: '/MurmurRPC.V1/UserKick', 821 | requestStream: false, 822 | responseStream: false, 823 | requestType: MurmurRPC_pb.User.Kick, 824 | responseType: MurmurRPC_pb.Void, 825 | requestSerialize: serialize_MurmurRPC_User_Kick, 826 | requestDeserialize: deserialize_MurmurRPC_User_Kick, 827 | responseSerialize: serialize_MurmurRPC_Void, 828 | responseDeserialize: deserialize_MurmurRPC_Void, 829 | }, 830 | // 831 | // Tree 832 | // 833 | // 834 | // TreeQuery returns a representation of the given server's channel/user 835 | // tree. 836 | treeQuery: { 837 | path: '/MurmurRPC.V1/TreeQuery', 838 | requestStream: false, 839 | responseStream: false, 840 | requestType: MurmurRPC_pb.Tree.Query, 841 | responseType: MurmurRPC_pb.Tree, 842 | requestSerialize: serialize_MurmurRPC_Tree_Query, 843 | requestDeserialize: deserialize_MurmurRPC_Tree_Query, 844 | responseSerialize: serialize_MurmurRPC_Tree, 845 | responseDeserialize: deserialize_MurmurRPC_Tree, 846 | }, 847 | // 848 | // Bans 849 | // 850 | // 851 | // BansGet returns a list of bans for the given server. 852 | bansGet: { 853 | path: '/MurmurRPC.V1/BansGet', 854 | requestStream: false, 855 | responseStream: false, 856 | requestType: MurmurRPC_pb.Ban.Query, 857 | responseType: MurmurRPC_pb.Ban.List, 858 | requestSerialize: serialize_MurmurRPC_Ban_Query, 859 | requestDeserialize: deserialize_MurmurRPC_Ban_Query, 860 | responseSerialize: serialize_MurmurRPC_Ban_List, 861 | responseDeserialize: deserialize_MurmurRPC_Ban_List, 862 | }, 863 | // BansSet replaces the server's ban list with the given list. 864 | bansSet: { 865 | path: '/MurmurRPC.V1/BansSet', 866 | requestStream: false, 867 | responseStream: false, 868 | requestType: MurmurRPC_pb.Ban.List, 869 | responseType: MurmurRPC_pb.Void, 870 | requestSerialize: serialize_MurmurRPC_Ban_List, 871 | requestDeserialize: deserialize_MurmurRPC_Ban_List, 872 | responseSerialize: serialize_MurmurRPC_Void, 873 | responseDeserialize: deserialize_MurmurRPC_Void, 874 | }, 875 | // 876 | // ACL 877 | // 878 | // 879 | // ACLGet returns the ACL for the given channel. 880 | aCLGet: { 881 | path: '/MurmurRPC.V1/ACLGet', 882 | requestStream: false, 883 | responseStream: false, 884 | requestType: MurmurRPC_pb.Channel, 885 | responseType: MurmurRPC_pb.ACL.List, 886 | requestSerialize: serialize_MurmurRPC_Channel, 887 | requestDeserialize: deserialize_MurmurRPC_Channel, 888 | responseSerialize: serialize_MurmurRPC_ACL_List, 889 | responseDeserialize: deserialize_MurmurRPC_ACL_List, 890 | }, 891 | // ACLSet overrides the ACL of the given channel to what is provided. 892 | aCLSet: { 893 | path: '/MurmurRPC.V1/ACLSet', 894 | requestStream: false, 895 | responseStream: false, 896 | requestType: MurmurRPC_pb.ACL.List, 897 | responseType: MurmurRPC_pb.Void, 898 | requestSerialize: serialize_MurmurRPC_ACL_List, 899 | requestDeserialize: deserialize_MurmurRPC_ACL_List, 900 | responseSerialize: serialize_MurmurRPC_Void, 901 | responseDeserialize: deserialize_MurmurRPC_Void, 902 | }, 903 | // ACLGetEffectivePermissions returns the effective permissions for the given 904 | // user in the given channel. 905 | aCLGetEffectivePermissions: { 906 | path: '/MurmurRPC.V1/ACLGetEffectivePermissions', 907 | requestStream: false, 908 | responseStream: false, 909 | requestType: MurmurRPC_pb.ACL.Query, 910 | responseType: MurmurRPC_pb.ACL, 911 | requestSerialize: serialize_MurmurRPC_ACL_Query, 912 | requestDeserialize: deserialize_MurmurRPC_ACL_Query, 913 | responseSerialize: serialize_MurmurRPC_ACL, 914 | responseDeserialize: deserialize_MurmurRPC_ACL, 915 | }, 916 | // ACLAddTemporaryGroup adds a user to a temporary group. 917 | aCLAddTemporaryGroup: { 918 | path: '/MurmurRPC.V1/ACLAddTemporaryGroup', 919 | requestStream: false, 920 | responseStream: false, 921 | requestType: MurmurRPC_pb.ACL.TemporaryGroup, 922 | responseType: MurmurRPC_pb.Void, 923 | requestSerialize: serialize_MurmurRPC_ACL_TemporaryGroup, 924 | requestDeserialize: deserialize_MurmurRPC_ACL_TemporaryGroup, 925 | responseSerialize: serialize_MurmurRPC_Void, 926 | responseDeserialize: deserialize_MurmurRPC_Void, 927 | }, 928 | // ACLRemoveTemporaryGroup removes a user from a temporary group. 929 | aCLRemoveTemporaryGroup: { 930 | path: '/MurmurRPC.V1/ACLRemoveTemporaryGroup', 931 | requestStream: false, 932 | responseStream: false, 933 | requestType: MurmurRPC_pb.ACL.TemporaryGroup, 934 | responseType: MurmurRPC_pb.Void, 935 | requestSerialize: serialize_MurmurRPC_ACL_TemporaryGroup, 936 | requestDeserialize: deserialize_MurmurRPC_ACL_TemporaryGroup, 937 | responseSerialize: serialize_MurmurRPC_Void, 938 | responseDeserialize: deserialize_MurmurRPC_Void, 939 | }, 940 | // 941 | // Authenticator 942 | // 943 | // 944 | // AuthenticatorStream opens an authentication stream to the server. 945 | // 946 | // There can only be one RPC client with an open Stream. If a new 947 | // authenticator connects, the open connected will be closed. 948 | authenticatorStream: { 949 | path: '/MurmurRPC.V1/AuthenticatorStream', 950 | requestStream: true, 951 | responseStream: true, 952 | requestType: MurmurRPC_pb.Authenticator.Response, 953 | responseType: MurmurRPC_pb.Authenticator.Request, 954 | requestSerialize: serialize_MurmurRPC_Authenticator_Response, 955 | requestDeserialize: deserialize_MurmurRPC_Authenticator_Response, 956 | responseSerialize: serialize_MurmurRPC_Authenticator_Request, 957 | responseDeserialize: deserialize_MurmurRPC_Authenticator_Request, 958 | }, 959 | // 960 | // Database 961 | // 962 | // 963 | // DatabaseUserQuery returns a list of registered users who match given 964 | // query. 965 | databaseUserQuery: { 966 | path: '/MurmurRPC.V1/DatabaseUserQuery', 967 | requestStream: false, 968 | responseStream: false, 969 | requestType: MurmurRPC_pb.DatabaseUser.Query, 970 | responseType: MurmurRPC_pb.DatabaseUser.List, 971 | requestSerialize: serialize_MurmurRPC_DatabaseUser_Query, 972 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser_Query, 973 | responseSerialize: serialize_MurmurRPC_DatabaseUser_List, 974 | responseDeserialize: deserialize_MurmurRPC_DatabaseUser_List, 975 | }, 976 | // DatabaseUserGet returns the database user with the given ID. 977 | databaseUserGet: { 978 | path: '/MurmurRPC.V1/DatabaseUserGet', 979 | requestStream: false, 980 | responseStream: false, 981 | requestType: MurmurRPC_pb.DatabaseUser, 982 | responseType: MurmurRPC_pb.DatabaseUser, 983 | requestSerialize: serialize_MurmurRPC_DatabaseUser, 984 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser, 985 | responseSerialize: serialize_MurmurRPC_DatabaseUser, 986 | responseDeserialize: deserialize_MurmurRPC_DatabaseUser, 987 | }, 988 | // DatabaseUserUpdate updates the given database user. 989 | databaseUserUpdate: { 990 | path: '/MurmurRPC.V1/DatabaseUserUpdate', 991 | requestStream: false, 992 | responseStream: false, 993 | requestType: MurmurRPC_pb.DatabaseUser, 994 | responseType: MurmurRPC_pb.Void, 995 | requestSerialize: serialize_MurmurRPC_DatabaseUser, 996 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser, 997 | responseSerialize: serialize_MurmurRPC_Void, 998 | responseDeserialize: deserialize_MurmurRPC_Void, 999 | }, 1000 | // DatabaseUserRegister registers a user with the given information on the 1001 | // server. The returned DatabaseUser will contain the newly registered user's 1002 | // ID. 1003 | databaseUserRegister: { 1004 | path: '/MurmurRPC.V1/DatabaseUserRegister', 1005 | requestStream: false, 1006 | responseStream: false, 1007 | requestType: MurmurRPC_pb.DatabaseUser, 1008 | responseType: MurmurRPC_pb.DatabaseUser, 1009 | requestSerialize: serialize_MurmurRPC_DatabaseUser, 1010 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser, 1011 | responseSerialize: serialize_MurmurRPC_DatabaseUser, 1012 | responseDeserialize: deserialize_MurmurRPC_DatabaseUser, 1013 | }, 1014 | // DatabaseUserDeregister deregisters the given user. 1015 | databaseUserDeregister: { 1016 | path: '/MurmurRPC.V1/DatabaseUserDeregister', 1017 | requestStream: false, 1018 | responseStream: false, 1019 | requestType: MurmurRPC_pb.DatabaseUser, 1020 | responseType: MurmurRPC_pb.Void, 1021 | requestSerialize: serialize_MurmurRPC_DatabaseUser, 1022 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser, 1023 | responseSerialize: serialize_MurmurRPC_Void, 1024 | responseDeserialize: deserialize_MurmurRPC_Void, 1025 | }, 1026 | // DatabaseUserVerify verifies the that the given user-password pair is 1027 | // correct. 1028 | databaseUserVerify: { 1029 | path: '/MurmurRPC.V1/DatabaseUserVerify', 1030 | requestStream: false, 1031 | responseStream: false, 1032 | requestType: MurmurRPC_pb.DatabaseUser.Verify, 1033 | responseType: MurmurRPC_pb.DatabaseUser, 1034 | requestSerialize: serialize_MurmurRPC_DatabaseUser_Verify, 1035 | requestDeserialize: deserialize_MurmurRPC_DatabaseUser_Verify, 1036 | responseSerialize: serialize_MurmurRPC_DatabaseUser, 1037 | responseDeserialize: deserialize_MurmurRPC_DatabaseUser, 1038 | }, 1039 | // 1040 | // Audio 1041 | // 1042 | // 1043 | // AddRedirectWhisperGroup add a whisper targets redirection for the given 1044 | // user. Whenever a user whispers to group "source", the whisper will be 1045 | // redirected to group "target". 1046 | redirectWhisperGroupAdd: { 1047 | path: '/MurmurRPC.V1/RedirectWhisperGroupAdd', 1048 | requestStream: false, 1049 | responseStream: false, 1050 | requestType: MurmurRPC_pb.RedirectWhisperGroup, 1051 | responseType: MurmurRPC_pb.Void, 1052 | requestSerialize: serialize_MurmurRPC_RedirectWhisperGroup, 1053 | requestDeserialize: deserialize_MurmurRPC_RedirectWhisperGroup, 1054 | responseSerialize: serialize_MurmurRPC_Void, 1055 | responseDeserialize: deserialize_MurmurRPC_Void, 1056 | }, 1057 | // RemoveRedirectWhisperGroup removes a whisper target redirection for 1058 | // the the given user. 1059 | redirectWhisperGroupRemove: { 1060 | path: '/MurmurRPC.V1/RedirectWhisperGroupRemove', 1061 | requestStream: false, 1062 | responseStream: false, 1063 | requestType: MurmurRPC_pb.RedirectWhisperGroup, 1064 | responseType: MurmurRPC_pb.Void, 1065 | requestSerialize: serialize_MurmurRPC_RedirectWhisperGroup, 1066 | requestDeserialize: deserialize_MurmurRPC_RedirectWhisperGroup, 1067 | responseSerialize: serialize_MurmurRPC_Void, 1068 | responseDeserialize: deserialize_MurmurRPC_Void, 1069 | }, 1070 | }; 1071 | 1072 | // 1073 | // Meta 1074 | // 1075 | -------------------------------------------------------------------------------- /lib/mumble-config-schema.yaml: -------------------------------------------------------------------------------- 1 | type: object 2 | requires: ["mumble_grpc_endpoint", "domain", "homeserverURL", "matrixRoom"] 3 | properties: 4 | mumble_grpc_endpoint: 5 | type: string 6 | domain: 7 | type: string 8 | homeserverURL: 9 | type: string 10 | matrixRoom: 11 | type: string -------------------------------------------------------------------------------- /mumble-config.yaml.example: -------------------------------------------------------------------------------- 1 | # Address where Murmur is listening for gRPC. This will be in Murmur's logs. 2 | mumble_grpc_endpoint: '127.0.0.1:50051' 3 | # Homeserver domain 4 | domain: 'example.com' 5 | # Homeserver URL 6 | homeserverURL: 'https://matrix.example.com/' 7 | # Internal ID of the Matrix room to use for bridge admin commands. 8 | # Anyone in this room will be able to link Mumble channels to Matrix. 9 | # Type "help" for commands, you should only use this room for bot admin tasks. 10 | # On Riot this is under 'Room Settings' => 'Advanced' => 'Room information'. 11 | matrixRoom: '!randomID:example.com' 12 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "matrix-appservice-mumble", 3 | "version": "0.2.0", 4 | "description": "Matrix to Mumble bridge", 5 | "scripts": { 6 | "build": "./build.sh", 7 | "gen-bindings": "./gen-bindings.sh" 8 | }, 9 | "repository": { 10 | "type": "git", 11 | "url": "https://github.com/mymindstorm/matrix-appservice-mumble.git" 12 | }, 13 | "bugs": { 14 | "url": "https://github.com/mymindstorm/matrix-appservice-mumble/issues/new" 15 | }, 16 | "author": "Brendan Early ", 17 | "license": "MIT", 18 | "dependencies": { 19 | "@grpc/grpc-js": "^1.3.7", 20 | "@seald-io/binary-search-tree": "^1.0.2", 21 | "@seald-io/nedb": "^2.0.4", 22 | "google-protobuf": "^3.18.0", 23 | "matrix-appservice-bridge": "^3.0.0" 24 | }, 25 | "devDependencies": { 26 | "@tsconfig/node12": "^1.0.9", 27 | "@types/google-protobuf": "^3.15.5", 28 | "@types/nedb": "^1.8.12", 29 | "@types/node": "^16.9.1", 30 | "grpc-tools": "^1.11.2", 31 | "grpc_tools_node_protoc_ts": "^5.3.2", 32 | "typescript": "^4.4.3" 33 | }, 34 | "bin": "bin/matrix-appservice-mumble", 35 | "files": [ 36 | "build" 37 | ] 38 | } 39 | -------------------------------------------------------------------------------- /src/Murmur.ts: -------------------------------------------------------------------------------- 1 | import {ClientReadableStream, credentials, makeClientConstructor} from "@grpc/grpc-js"; 2 | import * as MurmurService from '../lib/MurmurRPC_grpc_pb'; 3 | import {Channel, Server, TextMessage} from '../lib/MurmurRPC_pb'; 4 | import {Bridge, Intent, MatrixRoom, RoomBridgeStore, WeakEvent} from 'matrix-appservice-bridge'; 5 | import {MatrixClient} from "matrix-bot-sdk/lib/MatrixClient"; 6 | 7 | export default class Murmur { 8 | private readonly addr: string; 9 | private server: Server | undefined; 10 | private matrixClient: MatrixClient | undefined; 11 | client: MurmurService.V1Client | undefined; 12 | 13 | constructor(addr: string) { 14 | this.addr = addr; 15 | return; 16 | } 17 | 18 | // Init connection 19 | connectClient() { 20 | // @ts-ignore - bindings are wrong? 21 | const MurmurClient = makeClientConstructor(MurmurService["MurmurRPC.V1"], "MurmurRPC.V1") 22 | // @ts-ignore 23 | this.client = new MurmurClient( 24 | this.addr, 25 | credentials.createInsecure()); 26 | return this.client; 27 | } 28 | 29 | // Sets server to the first running one and returns server stream 30 | getServerStream(): Promise> { 31 | return new Promise((resolve) => { 32 | if (!this.client) { 33 | console.log("Murmur client connection null!"); 34 | process.exit(1); 35 | } 36 | 37 | this.client.serverQuery(new Server.Query(), (e, r) => { 38 | if (!this.client) { 39 | console.log("Murmur client connection null!"); 40 | process.exit(1); 41 | } 42 | 43 | if (e) { 44 | console.log(e); 45 | process.exit(1); 46 | } else if (r) { 47 | let server; 48 | for (const currentServer of r.getServersList()) { 49 | if (currentServer.getRunning()) { 50 | server = currentServer; 51 | break; 52 | } 53 | } 54 | 55 | if (!server) { 56 | console.log('No servers running!'); 57 | process.exit(1); 58 | return; 59 | } 60 | 61 | this.server = server; 62 | resolve(this.client.serverEvents(this.server)); 63 | } 64 | }); 65 | }); 66 | } 67 | 68 | async setupCallbacks(bridge: Bridge, roomLinks: RoomBridgeStore, config: MurmurConfig) { 69 | const stream = await this.getServerStream(); 70 | 71 | async function getMatrixRooms(channelId?: number | Channel[]): Promise { 72 | if (!channelId) { 73 | return []; 74 | } 75 | 76 | if (typeof channelId === "object") { 77 | let mtxRooms: MatrixRoom[] = []; 78 | for (const channel of channelId) { 79 | mtxRooms = mtxRooms.concat(await roomLinks.getLinkedMatrixRooms(String(channel.getId()))); 80 | } 81 | return mtxRooms; 82 | } else { 83 | return await roomLinks.getLinkedMatrixRooms(String(channelId)); 84 | } 85 | } 86 | 87 | async function onUserConnected(event: Server.Event, intent: Intent) { 88 | const connMtxRooms = await roomLinks.getEntriesByLinkData({send_join_part: true}); 89 | if (!connMtxRooms.length) { 90 | return; 91 | } 92 | 93 | for (const room of connMtxRooms) { 94 | const mtxId = room.matrix?.getId(); 95 | if (!mtxId) { 96 | continue; 97 | } 98 | await intent.sendMessage(mtxId, { 99 | body: `${event.getUser()?.getName()} has connected to the server.`, 100 | msgtype: "m.notice" 101 | }); 102 | } 103 | } 104 | 105 | async function onUserDisconnected(event: Server.Event, intent: Intent) { 106 | const disconnMtxRooms = await roomLinks.getEntriesByLinkData({send_join_part: true}); 107 | if (!disconnMtxRooms.length) { 108 | return; 109 | } 110 | 111 | for (const room of disconnMtxRooms) { 112 | const mtxId = room.matrix?.getId(); 113 | if (!mtxId) { 114 | continue; 115 | } 116 | await intent.sendMessage(mtxId, { 117 | body: `${event.getUser()?.getName()} has disconnected from the server.`, 118 | msgtype: "m.notice" 119 | }); 120 | } 121 | } 122 | 123 | async function onTextMessage(event: Server.Event) { 124 | const textMtxRooms = await getMatrixRooms(event.getMessage()?.getChannelsList()); 125 | if (!textMtxRooms.length) { 126 | return; 127 | } 128 | 129 | const userIntent = bridge.getIntent(`@mumble_${event.getUser()?.getName()}:${config.domain}`); 130 | for (const room of textMtxRooms) { 131 | await userIntent.sendMessage(room.getId(), { 132 | body: event.getMessage()?.getText(), 133 | format: "org.matrix.custom.html", 134 | formatted_body: event.getMessage()?.getText(), 135 | msgtype: "m.text" 136 | }); 137 | } 138 | } 139 | 140 | stream.on('data', (event: Server.Event) => { 141 | switch (event.getType()) { 142 | case Server.Event.Type.USERCONNECTED: 143 | onUserConnected(event, bridge.getIntent()) 144 | .catch((err) => console.error("Error when sending user connection message:", err)); 145 | break; 146 | case Server.Event.Type.USERDISCONNECTED: 147 | onUserDisconnected(event, bridge.getIntent()) 148 | .catch((err) => console.error("Error when sending user disconnection message:", err)); 149 | break; 150 | case Server.Event.Type.USERTEXTMESSAGE: 151 | onTextMessage(event) 152 | .catch((err) => console.error("Error when sending text message:", err)); 153 | break; 154 | default: 155 | break; 156 | } 157 | return; 158 | }); 159 | 160 | // stream.on error 161 | return; 162 | } 163 | 164 | setMatrixClient(client: MatrixClient) { 165 | this.matrixClient = client; 166 | return; 167 | } 168 | 169 | // Matrix message -> Mumble 170 | sendMessage(event: WeakEvent, linkedRooms: number[], displayname?: string) { 171 | if (!this.client || !this.server || !this.matrixClient || !event.content) { 172 | return; 173 | } 174 | 175 | let messageContent = event.content.body; 176 | if (event.content.msgtype === "m.image" || event.content.msgtype === "m.file") { 177 | const url = this.matrixClient.mxcToHttp(event.content.url as string); 178 | if (url) { 179 | messageContent = `${event.content.body}`; 180 | } 181 | } 182 | 183 | if (event.content.msgtype === "m.text" 184 | && event.content.format === "org.matrix.custom.html" 185 | && event.content.formatted_body) { 186 | messageContent = event.content.formatted_body; 187 | } 188 | 189 | // If displayname was not provided, fall back to username 190 | if (!displayname) { 191 | displayname = event.sender; 192 | } 193 | 194 | const message = new TextMessage(); 195 | message.setServer(this.server); 196 | for (const roomId of linkedRooms) { 197 | message.addChannels(new Channel().setId(roomId)); 198 | } 199 | message.setText(`${displayname}: ${messageContent}`); 200 | 201 | this.client.textMessageSend(message, () => { }); 202 | 203 | return; 204 | } 205 | 206 | // Get Mumble channel id from channel name 207 | getChannelId(channelName: string): Promise { 208 | const query = new Channel.Query(); 209 | query.setServer(this.server); 210 | return new Promise((resolve) => { 211 | this.client?.channelQuery(query, (err, res) => { 212 | if (err) { 213 | console.error("Murmur channel lookup error:", err); 214 | resolve(undefined); 215 | return; 216 | } 217 | 218 | for (const channel of res.getChannelsList()) { 219 | if (channelName.trim() === channel.getName()?.trim()) { 220 | resolve(channel.getId()); 221 | return; 222 | } 223 | } 224 | 225 | resolve(undefined); 226 | }); 227 | }); 228 | } 229 | }; 230 | -------------------------------------------------------------------------------- /src/helpText.ts: -------------------------------------------------------------------------------- 1 | const helpText = { 2 | body: "Command Reference: \n\ 3 | - link [true] \n\ 4 | - Use \"root_channel\" instead of a channel name to link the topmost channel in Mumble \n\ 5 | - Set \"true\" to send join/leave part messages to the linked Matrix room \n\ 6 | - unlink matrix \n\ 7 | - unlink mumble \n\ 8 | - help \n\ 9 | \n\ 10 | More info: https://github.com/mymindstorm/matrix-appservice-mumble/blob/master/README.md#configure", 11 | formatted_body: "

Command Reference

\ 12 |
    \ 13 |
  • link <Matrix room ID> <Mumble channel name | root_channel> [true] \ 14 |
      \ 15 |
    • Use root_channel instead of a channel name to link the topmost channel in Mumble
      • \ 16 |
    • Set true to send join/leave part messages to the linked Matrix room
      • \ 17 |
    \ 18 |
    • \ 19 |
  • unlink matrix <Matrix room ID>
    • \ 20 |
  • unlink mumble <Mumble channel name | root_channel>
    • \ 21 |
  • help
    • \ 22 |
\ 23 | More info" 24 | }; 25 | 26 | export default helpText; 27 | -------------------------------------------------------------------------------- /src/main.ts: -------------------------------------------------------------------------------- 1 | import Murmur from './Murmur'; 2 | import { 3 | AppServiceRegistration, 4 | Bridge, 5 | BridgeContext, 6 | Cli, 7 | CliOpts, 8 | Intent, 9 | MatrixRoom, 10 | RemoteRoom, 11 | Request, 12 | RoomBridgeStore, 13 | WeakEvent 14 | } from 'matrix-appservice-bridge'; 15 | import nedb from 'nedb'; 16 | import helpText from './helpText'; 17 | 18 | async function runBridge(config: MurmurConfig, port: number) { 19 | // Persistent DB with Matrix room <-> Mumble channel links 20 | const roomLinkDb = new nedb({ 21 | filename: "./room-links.db", 22 | autoload: true 23 | }); 24 | const roomLinks = new RoomBridgeStore(roomLinkDb); 25 | 26 | console.log('Connecting to Murmur...'); 27 | const murmur = new Murmur(config.mumble_grpc_endpoint); 28 | await murmur.connectClient(); 29 | if (!murmur.client) { 30 | console.log('Connection error.'); 31 | process.exit(1); 32 | } 33 | console.log('Connetion to Murmur established!'); 34 | 35 | async function linkCommand(args: string[], intent: Intent) { 36 | const mtxRoomId = args[1]; 37 | let mumbleChanName = args.slice(2).join(' '); 38 | let sendJoinPart = false; 39 | 40 | if (mumbleChanName.substring(mumbleChanName.length - 4) === "true") { 41 | sendJoinPart = true; 42 | mumbleChanName = mumbleChanName.substring(0, mumbleChanName.length - 4); 43 | } 44 | mumbleChanName = mumbleChanName.trim(); 45 | 46 | if (!mtxRoomId && !mumbleChanName) { 47 | await intent.sendText(config.matrixRoom, "Invalid command. Type 'help' for valid commands."); 48 | return; 49 | } 50 | 51 | // try to join the room 52 | try { 53 | await intent.join(mtxRoomId); 54 | } catch (err) { 55 | await intent.sendText(config.matrixRoom, "Could not join Matrix room."); 56 | return; 57 | } 58 | 59 | let mumbleChanId: number | undefined; 60 | if (mumbleChanName === "root_channel") { 61 | mumbleChanId = 0; 62 | } else { 63 | mumbleChanId = await murmur.getChannelId(mumbleChanName); 64 | if (!mumbleChanId) { 65 | await intent.sendText(config.matrixRoom, "Could not find Mumble channel."); 66 | return; 67 | } 68 | } 69 | 70 | await roomLinks.linkRooms(new MatrixRoom(mtxRoomId), new RemoteRoom(String(mumbleChanId)), {send_join_part: sendJoinPart}); 71 | await intent.sendText(config.matrixRoom, "Link successful!"); 72 | } 73 | 74 | async function unlinkCommand(args: string[], intent: Intent) { 75 | const delinkType = args[1]; 76 | 77 | if (delinkType === "matrix") { 78 | const mtxRoomId = args[2]; 79 | if (!mtxRoomId) { 80 | await intent.sendText(config.matrixRoom, "Invalid command. Type 'help' for valid commands."); 81 | return; 82 | } 83 | 84 | await roomLinks.removeEntriesByMatrixRoomId(mtxRoomId); 85 | await intent.sendText(config.matrixRoom, "Unlink successful!"); 86 | } else if (delinkType === "mumble") { 87 | const mumbleChanName = args.slice(2).join(' ').trim(); 88 | if (!mumbleChanName) { 89 | await intent.sendText(config.matrixRoom, "Invalid command. Type 'help' for valid commands."); 90 | return; 91 | } 92 | 93 | let mumbleChanId: number | undefined; 94 | if (mumbleChanName === "root_channel") { 95 | mumbleChanId = 0; 96 | } else { 97 | mumbleChanId = await murmur.getChannelId(mumbleChanName); 98 | if (!mumbleChanId) { 99 | await intent.sendText(config.matrixRoom, "Could not find Mumble channel."); 100 | return; 101 | } 102 | } 103 | 104 | await roomLinks.removeEntriesByRemoteRoomId(String(mumbleChanId)); 105 | await intent.sendText(config.matrixRoom, "Unlink successful!"); 106 | } else { 107 | await intent.sendText(config.matrixRoom, "Invalid command. Type 'help' for valid commands."); 108 | } 109 | } 110 | 111 | async function sendMessageToMumble(event: WeakEvent, intent: Intent) { 112 | const linkedRooms = await roomLinks.getLinkedRemoteRooms(event.room_id); 113 | 114 | if (!linkedRooms.length) { 115 | // If no linked rooms do not bridge message 116 | return; 117 | } 118 | 119 | // Send message to linked rooms 120 | // Get user display name 121 | let displayname; 122 | try { 123 | // Retrieve the display name 124 | const profile = await intent.getProfileInfo(event.sender, 'displayname'); 125 | displayname = profile.displayname; 126 | } catch (err) { 127 | console.error(`Exception fetching matrix profile of ${event.sender}:`, err); 128 | } 129 | 130 | let linkedRoomIds: number[] = []; 131 | for (const mumbleChannel of linkedRooms) { 132 | linkedRoomIds.push(Number(mumbleChannel.getId())) 133 | } 134 | murmur.sendMessage(event, linkedRoomIds, displayname); 135 | } 136 | 137 | const bridge = new Bridge({ 138 | homeserverUrl: config.homeserverURL, 139 | domain: config.domain, 140 | registration: 'mumble-registration.yaml', 141 | controller: { 142 | onEvent(request: Request, _: BridgeContext | undefined): void { 143 | const event = request.getData(); 144 | if (event.type !== 'm.room.message' || !event.content) { 145 | return; 146 | } else if (event.sender === `@mumblebot:${config.domain}`) { 147 | return; 148 | } 149 | 150 | if (event.room_id === config.matrixRoom && event.content.msgtype === "m.text") { 151 | // Process admin room commands 152 | // TODO: consider using a library to parse input 153 | const commandArgs = (event.content.body as string)?.split(' ') || ["invalid command"]; 154 | switch (commandArgs[0]) { 155 | case "link": 156 | linkCommand(commandArgs, bridge.getIntent()) 157 | .catch((err) => console.error("Error when linking rooms:", err)); 158 | break; 159 | case "unlink": 160 | unlinkCommand(commandArgs, bridge.getIntent()) 161 | .catch((err) => console.error("Error when unlinking rooms:", err)); 162 | break; 163 | case "help": 164 | bridge.getIntent().sendMessage(config.matrixRoom, { 165 | ...helpText, 166 | format: "org.matrix.custom.html", 167 | msgtype: "m.text" 168 | }).catch((err) => console.error("Error when sending help:", err)); 169 | break; 170 | default: 171 | break; 172 | } 173 | } else { 174 | sendMessageToMumble(event, bridge.getIntent()) 175 | } 176 | } 177 | }, 178 | }); 179 | console.log('Matrix-side listening on port %s', port); 180 | await murmur.setupCallbacks(bridge, roomLinks, config); 181 | await bridge.initalise(); 182 | await bridge.listen(port); 183 | murmur.setMatrixClient(bridge.getBot().getClient()); 184 | await bridge.getIntent().sendText(config.matrixRoom, "Bridge running"); 185 | 186 | return async () => { 187 | await bridge.close() 188 | murmur.client?.close() 189 | } 190 | } 191 | 192 | function main() { 193 | 194 | new Cli(new class implements CliOpts { 195 | registrationPath = 'mumble-registration.yaml'; 196 | 197 | generateRegistration(reg: AppServiceRegistration, cb: (finalReg: AppServiceRegistration) => void): void { 198 | reg.setId(AppServiceRegistration.generateToken()); 199 | reg.setHomeserverToken(AppServiceRegistration.generateToken()); 200 | reg.setAppServiceToken(AppServiceRegistration.generateToken()); 201 | reg.setSenderLocalpart('mumblebot'); 202 | reg.addRegexPattern('users', '@mumble_.*', true); 203 | cb(reg); 204 | } 205 | 206 | bridgeConfig = { 207 | schema: __dirname + '/mumble-config-schema.yaml', 208 | defaults: {}, 209 | }; 210 | 211 | run(port: number | null, config: MurmurConfig | null, _: AppServiceRegistration | null): void { 212 | if (config == null) { 213 | console.error("No config provided. Cannot start."); 214 | process.exit(1); 215 | } 216 | if (port == null) { 217 | port = 8080; 218 | } 219 | console.log('Bridge startup...'); 220 | runBridge(config, port) 221 | .then((stopCallback) => { 222 | console.log("Bridge startup complete!"); 223 | process.on("SIGTERM", async () => { 224 | console.log("Got SIGTERM"); 225 | try { 226 | await stopCallback(); 227 | } catch (err) { 228 | console.error("Failed to stop bridge", err); 229 | process.exit(1); 230 | } 231 | process.exit(0); 232 | }); 233 | }) 234 | .catch((err) => { 235 | console.error("Error when starting bridge:", err); 236 | process.exit(1); 237 | }); 238 | } 239 | }).run(); 240 | } 241 | 242 | main(); 243 | -------------------------------------------------------------------------------- /src/types.d.ts: -------------------------------------------------------------------------------- 1 | interface MurmurConfig extends Record { 2 | domain: string; 3 | matrixRoom: string; 4 | mumble_grpc_endpoint: string; 5 | homeserverURL: string; 6 | } 7 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": "@tsconfig/node12/tsconfig.json", 3 | 4 | "compilerOptions": { 5 | "outDir": "./build", 6 | "rootDir": "./src", 7 | 8 | // strict checking is enabled through tsconfig, the following strict settings are set explicitly 9 | "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */ 10 | "strictNullChecks": true, /* Enable strict null checks. */ 11 | "strictFunctionTypes": true, /* Enable strict checking of function types. */ 12 | "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */ 13 | "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */ 14 | "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */ 15 | "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */ 16 | "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ 17 | "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ 18 | }, 19 | } 20 | --------------------------------------------------------------------------------