Initial checkin

.gitignore

@@ -0,0 +1 @@
+/target

.rustfmt.toml

@@ -0,0 +1 @@
+edition = "2018"

Cargo.lock

@@ -0,0 +1,46 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "anyhow"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9a60d744a80c30fcb657dfe2c1b22bcb3e814c1a1e3674f32bf5820b570fbff"
+
+[[package]]
+name = "dbus"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f8875bb7afbc20dec12db09e18af3dcbd672b08592d2932950326a6437c616"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99e85c08494b21a9054e7fe1374a732aeadaff3980b6990b94bfd3a70f690005"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc12a3bc971424edbbf7edaf6e5740483444db63aa8e23d3751ff12a30f306f0"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05da548ad6865900e60eaba7f589cc0783590a92e940c26953ff81ddbab2d677"
+
+[[package]]
+name = "telepathy-padfoot"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "dbus",
+]

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "telepathy-padfoot"
+version = "0.1.0"
+authors = ["Nick Thomas <me@ur.gs>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0"
+dbus = "0.8.2"

LICENSE

@@ -0,0 +1,18 @@
+Copyright 2020 Nick Thomas <telepathy-delta@ur.gs>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,41 @@
+# Telepathy for Delta Chat
+
+## Who
+
+Authored by [Nick Thomas](https://ur.gs) under the [MIT License](LICENSE).
+
+## What
+
+[Delta Chat](https://delta.chat) is IM over email.
+[Telepathy](https://telepathy.freedesktop.org) is a framework for abstracting
+over multiple IM protocols. This project glues the two together, allowing
+Telepathy clients to send/receive Delta messages.
+
+Telepathy CMs should have a name that is not the same as their protocol; so this
+CM is hereby named "padfoot".
+
+## Why
+
+Mobile IM, mostly. Desktop IM, also. It's ideal for my pinephone, and lighter
+than the electron desktop client.
+
+## How
+
+This project is written in Rust, just like the main Delta library, so you'll
+need a rust compiler to build it.
+
+It makes use of the `dbus-codegen-rust` crate to convert the
+[telepathy interface specs](https://github.com/TelepathyIM/telepathy-spec) into
+the executable code in `src/telepathy`. This is checked in, but can be
+regenerated like so:
+
+```bash
+$ git submodule init telepathy-spec
+$ git submodule update telepathy-spec
+$ cargo install dbus-codegen-rust
+$ ./scripts/dbus-codegen
+```
+
+`dbus-codegen-rust` doesn't seem to handle namespaced attributes properly, so
+we modify the XML files in `telepathy-spec`... with `sed`. The `tp:type`
+attribute is renamed to `tp:typehint`.

scripts/dbus-codegen

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+specs="telepathy-spec/spec"
+dest="src/telepathy"
+modfile="$dest.rs"
+
+#if [ -d "$dest" ]; then
+#	mv "$dest" "$dest.$$"
+#fi
+
+rm -f "$dest.rs"
+rm -rf "$dest"
+mkdir -p "$dest"
+
+echo "#![allow(unused)]\n#![allow(clippy::all)]" > "$modfile"
+
+for file in $(ls -a $specs/*.xml); do
+	sed -i 's/tp:type=/tp:typehint=/g' "$file"
+
+	name=$( \
+		echo $(basename "$file") | \
+		tr '[:upper:]' '[:lower:]' | \
+		tr '-' '_' | \
+		sed --expression 's/\.xml$//' \
+	)
+	out="$dest/$name.rs"
+
+	dbus-codegen-rust \
+		--file "$file" \
+		-i "org.freedesktop.Telepathy" \
+		-o "$out"
+
+	rustfmt $out
+
+	echo "\nmod $name;\npub use self::$name::*;" >> "$modfile"
+done
+
+git -C telepathy-spec checkout -- .

src/main.rs

@@ -0,0 +1,73 @@
+mod padfoot;
+mod telepathy;
+
+//use dbus::tree::{Interface, MTFn, MethodErr};
+use dbus::{
+    blocking::{stdintf::org_freedesktop_dbus::RequestNameReply, LocalConnection},
+    tree::{Factory, Interface, MTFn, Tree},
+};
+
+use padfoot::{CMData, ConnectionManager};
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{anyhow, Result};
+
+const BUS_NAME: &'static str = "org.freedesktop.Telepathy.ConnectionManager.padfoot";
+const OBJECT_PATH: &'static str = "/org/freedesktop/Telepathy/ConnectionManager/padfoot";
+
+fn create_tree(cm: &Arc<ConnectionManager>) -> Tree<MTFn<CMData>, CMData> {
+    let f = Factory::new_fn();
+    let mut tree = f.tree(());
+
+    let iface = telepathy::connection_manager_server(&f, (), |m| {
+        let a: &Arc<ConnectionManager> = m.path.get_data();
+        let b: &ConnectionManager = &a;
+
+        b
+    });
+
+    tree = tree.add(
+        f.object_path(OBJECT_PATH, cm.clone())
+            .introspectable()
+            .add(iface),
+    );
+    tree = tree.add(f.object_path("/", cm.clone()).introspectable());
+
+    tree
+}
+
+fn run() -> Result<()> {
+    let cm: ConnectionManager = ConnectionManager {};
+    let tree = create_tree(&Arc::new(cm));
+
+    // Setup DBus connection
+    let mut c = LocalConnection::new_session()?;
+
+    let result = c.request_name(BUS_NAME, false, false, true)?;
+    match result {
+        RequestNameReply::Exists => {
+            return Err(anyhow!(
+                "Another process is already registered on {}",
+                BUS_NAME
+            ))
+        }
+        _ => {} // All other responses we can get are a success
+    };
+
+    println!("Bus registered: {}", BUS_NAME);
+    tree.start_receive(&c);
+
+    loop {
+        c.process(Duration::from_secs(1))?;
+        println!("Tick");
+    }
+}
+
+fn main() {
+    if let Err(e) = run() {
+        println!("{}", e);
+        std::process::exit(1);
+    }
+}

src/padfoot.rs

@@ -0,0 +1,5 @@
+mod connection_manager;
+pub use self::connection_manager::*;
+
+mod protocol;
+pub use self::protocol::*;

src/padfoot/connection_manager.rs

@@ -0,0 +1,64 @@
+use crate::telepathy;
+use dbus::{arg, tree};
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub struct ConnectionManager {}
+
+#[derive(Copy, Clone, Default, Debug)]
+pub struct CMData;
+
+impl dbus::tree::DataType for CMData {
+    type Tree = ();
+    type Property = ();
+    type Interface = ();
+    type Method = ();
+    type Signal = ();
+    type ObjectPath = std::sync::Arc<ConnectionManager>;
+}
+
+const PROTO: &'static str = "delta";
+
+pub type Dict = HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>;
+
+impl telepathy::ConnectionManager for ConnectionManager {
+    fn get_parameters(
+        &self,
+        protocol: &str,
+    ) -> Result<
+        Vec<(
+            String,
+            u32,
+            String,
+            arg::Variant<Box<dyn arg::RefArg + 'static>>,
+        )>,
+        tree::MethodErr,
+    > {
+        Err(tree::MethodErr::no_arg()) // FIXME: should be NotImplemented
+    }
+
+    fn list_protocols(&self) -> Result<Vec<String>, tree::MethodErr> {
+        Ok(vec![PROTO.to_string()])
+    }
+
+    fn request_connection(
+        &self,
+        protocol: &str,
+        parameters: HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(String, dbus::Path<'static>), tree::MethodErr> {
+        Err(tree::MethodErr::no_arg())
+    }
+
+    fn protocols(&self) -> Result<HashMap<String, Dict>, tree::MethodErr> {
+        let mut hm = HashMap::new();
+        let mut props = Dict::new();
+
+        hm.insert(PROTO.to_string(), props);
+
+        Ok(hm)
+    }
+
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr> {
+        Err(tree::MethodErr::no_arg())
+    }
+}

src/padfoot/protocol.rs

@@ -0,0 +1,2 @@
+pub struct Protocol {}
+

src/telepathy.rs

@@ -0,0 +1,365 @@
+#![allow(unused)]
+#![allow(clippy::all)]
+
+mod account_interface_addressing;
+pub use self::account_interface_addressing::*;
+
+mod account_interface_avatar;
+pub use self::account_interface_avatar::*;
+
+mod account_interface_external_password_storage;
+pub use self::account_interface_external_password_storage::*;
+
+mod account_interface_hidden;
+pub use self::account_interface_hidden::*;
+
+mod account_interface_storage;
+pub use self::account_interface_storage::*;
+
+mod account_manager_interface_hidden;
+pub use self::account_manager_interface_hidden::*;
+
+mod account_manager;
+pub use self::account_manager::*;
+
+mod account;
+pub use self::account::*;
+
+mod all;
+pub use self::all::*;
+
+mod authentication_tls_certificate;
+pub use self::authentication_tls_certificate::*;
+
+mod call_content_interface_audio_control;
+pub use self::call_content_interface_audio_control::*;
+
+mod call_content_interface_dtmf;
+pub use self::call_content_interface_dtmf::*;
+
+mod call_content_interface_media;
+pub use self::call_content_interface_media::*;
+
+mod call_content_interface_video_control;
+pub use self::call_content_interface_video_control::*;
+
+mod call_content_media_description_interface_rtcp_extended_reports;
+pub use self::call_content_media_description_interface_rtcp_extended_reports::*;
+
+mod call_content_media_description_interface_rtcp_feedback;
+pub use self::call_content_media_description_interface_rtcp_feedback::*;
+
+mod call_content_media_description_interface_rtp_header_extensions;
+pub use self::call_content_media_description_interface_rtp_header_extensions::*;
+
+mod call_content_media_description;
+pub use self::call_content_media_description::*;
+
+mod call_content;
+pub use self::call_content::*;
+
+mod call_interface_mute;
+pub use self::call_interface_mute::*;
+
+mod call_stream_endpoint;
+pub use self::call_stream_endpoint::*;
+
+mod call_stream_interface_media;
+pub use self::call_stream_interface_media::*;
+
+mod call_stream;
+pub use self::call_stream::*;
+
+mod channel_bundle;
+pub use self::channel_bundle::*;
+
+mod channel_dispatcher_interface_messages1;
+pub use self::channel_dispatcher_interface_messages1::*;
+
+mod channel_dispatcher_interface_operation_list;
+pub use self::channel_dispatcher_interface_operation_list::*;
+
+mod channel_dispatcher;
+pub use self::channel_dispatcher::*;
+
+mod channel_dispatch_operation;
+pub use self::channel_dispatch_operation::*;
+
+mod channel_future;
+pub use self::channel_future::*;
+
+mod channel_handler;
+pub use self::channel_handler::*;
+
+mod channel_interface_addressing;
+pub use self::channel_interface_addressing::*;
+
+mod channel_interface_anonymity;
+pub use self::channel_interface_anonymity::*;
+
+mod channel_interface_call_state;
+pub use self::channel_interface_call_state::*;
+
+mod channel_interface_captcha_authentication;
+pub use self::channel_interface_captcha_authentication::*;
+
+mod channel_interface_chat_state;
+pub use self::channel_interface_chat_state::*;
+
+mod channel_interface_conference;
+pub use self::channel_interface_conference::*;
+
+mod channel_interface_credentials_storage;
+pub use self::channel_interface_credentials_storage::*;
+
+mod channel_interface_destroyable;
+pub use self::channel_interface_destroyable::*;
+
+mod channel_interface_dtmf;
+pub use self::channel_interface_dtmf::*;
+
+mod channel_interface_file_transfer_metadata;
+pub use self::channel_interface_file_transfer_metadata::*;
+
+mod channel_interface_group;
+pub use self::channel_interface_group::*;
+
+mod channel_interface_hold;
+pub use self::channel_interface_hold::*;
+
+mod channel_interface_html;
+pub use self::channel_interface_html::*;
+
+mod channel_interface_media_signalling;
+pub use self::channel_interface_media_signalling::*;
+
+mod channel_interface_mergeable_conference;
+pub use self::channel_interface_mergeable_conference::*;
+
+mod channel_interface_messages;
+pub use self::channel_interface_messages::*;
+
+mod channel_interface_password;
+pub use self::channel_interface_password::*;
+
+mod channel_interface_picture;
+pub use self::channel_interface_picture::*;
+
+mod channel_interface_room_config;
+pub use self::channel_interface_room_config::*;
+
+mod channel_interface_room;
+pub use self::channel_interface_room::*;
+
+mod channel_interface_sasl_authentication;
+pub use self::channel_interface_sasl_authentication::*;
+
+mod channel_interface_securable;
+pub use self::channel_interface_securable::*;
+
+mod channel_interface_service_point;
+pub use self::channel_interface_service_point::*;
+
+mod channel_interface_sms;
+pub use self::channel_interface_sms::*;
+
+mod channel_interface_splittable;
+pub use self::channel_interface_splittable::*;
+
+mod channel_interface_subject;
+pub use self::channel_interface_subject::*;
+
+mod channel_interface_transfer;
+pub use self::channel_interface_transfer::*;
+
+mod channel_interface_tube;
+pub use self::channel_interface_tube::*;
+
+mod channel_request;
+pub use self::channel_request::*;
+
+mod channel_type_call;
+pub use self::channel_type_call::*;
+
+mod channel_type_contact_list;
+pub use self::channel_type_contact_list::*;
+
+mod channel_type_contact_search;
+pub use self::channel_type_contact_search::*;
+
+mod channel_type_dbus_tube;
+pub use self::channel_type_dbus_tube::*;
+
+mod channel_type_file_transfer;
+pub use self::channel_type_file_transfer::*;
+
+mod channel_type_room_list;
+pub use self::channel_type_room_list::*;
+
+mod channel_type_server_authentication;
+pub use self::channel_type_server_authentication::*;
+
+mod channel_type_server_tls_connection;
+pub use self::channel_type_server_tls_connection::*;
+
+mod channel_type_streamed_media;
+pub use self::channel_type_streamed_media::*;
+
+mod channel_type_stream_tube;
+pub use self::channel_type_stream_tube::*;
+
+mod channel_type_text;
+pub use self::channel_type_text::*;
+
+mod channel_type_tubes;
+pub use self::channel_type_tubes::*;
+
+mod channel;
+pub use self::channel::*;
+
+mod client_approver;
+pub use self::client_approver::*;
+
+mod client_handler_future;
+pub use self::client_handler_future::*;
+
+mod client_handler;
+pub use self::client_handler::*;
+
+mod client_interface_requests;
+pub use self::client_interface_requests::*;
+
+mod client_observer;
+pub use self::client_observer::*;
+
+mod client;
+pub use self::client::*;
+
+mod connection_interface_addressing;
+pub use self::connection_interface_addressing::*;
+
+mod connection_interface_aliasing;
+pub use self::connection_interface_aliasing::*;
+
+mod connection_interface_anonymity;
+pub use self::connection_interface_anonymity::*;
+
+mod connection_interface_avatars;
+pub use self::connection_interface_avatars::*;
+
+mod connection_interface_balance;
+pub use self::connection_interface_balance::*;
+
+mod connection_interface_capabilities;
+pub use self::connection_interface_capabilities::*;
+
+mod connection_interface_cellular;
+pub use self::connection_interface_cellular::*;
+
+mod connection_interface_client_types;
+pub use self::connection_interface_client_types::*;
+
+mod connection_interface_communication_policy;
+pub use self::connection_interface_communication_policy::*;
+
+mod connection_interface_contact_blocking;
+pub use self::connection_interface_contact_blocking::*;
+
+mod connection_interface_contact_capabilities;
+pub use self::connection_interface_contact_capabilities::*;
+
+mod connection_interface_contact_groups;
+pub use self::connection_interface_contact_groups::*;
+
+mod connection_interface_contact_info;
+pub use self::connection_interface_contact_info::*;
+
+mod connection_interface_contact_list;
+pub use self::connection_interface_contact_list::*;
+
+mod connection_interface_contacts;
+pub use self::connection_interface_contacts::*;
+
+mod connection_interface_forwarding;
+pub use self::connection_interface_forwarding::*;
+
+mod connection_interface_irc_command1;
+pub use self::connection_interface_irc_command1::*;
+
+mod connection_interface_keepalive;
+pub use self::connection_interface_keepalive::*;
+
+mod connection_interface_location;
+pub use self::connection_interface_location::*;
+
+mod connection_interface_mail_notification;
+pub use self::connection_interface_mail_notification::*;
+
+mod connection_interface_power_saving;
+pub use self::connection_interface_power_saving::*;
+
+mod connection_interface_presence;
+pub use self::connection_interface_presence::*;
+
+mod connection_interface_privacy;
+pub use self::connection_interface_privacy::*;
+
+mod connection_interface_renaming;
+pub use self::connection_interface_renaming::*;
+
+mod connection_interface_requests;
+pub use self::connection_interface_requests::*;
+
+mod connection_interface_resources;
+pub use self::connection_interface_resources::*;
+
+mod connection_interface_service_point;
+pub use self::connection_interface_service_point::*;
+
+mod connection_interface_sidecars1;
+pub use self::connection_interface_sidecars1::*;
+
+mod connection_interface_simple_presence;
+pub use self::connection_interface_simple_presence::*;
+
+mod connection_manager_interface_account_storage;
+pub use self::connection_manager_interface_account_storage::*;
+
+mod connection_manager;
+pub use self::connection_manager::*;
+
+mod connection;
+pub use self::connection::*;
+
+mod debug;
+pub use self::debug::*;
+
+mod errors;
+pub use self::errors::*;
+
+mod generic_types;
+pub use self::generic_types::*;
+
+mod media_session_handler;
+pub use self::media_session_handler::*;
+
+mod media_stream_handler;
+pub use self::media_stream_handler::*;
+
+mod properties_interface;
+pub use self::properties_interface::*;
+
+mod protocol_interface_addressing;
+pub use self::protocol_interface_addressing::*;
+
+mod protocol_interface_avatars;
+pub use self::protocol_interface_avatars::*;
+
+mod protocol_interface_presence;
+pub use self::protocol_interface_presence::*;
+
+mod protocol;
+pub use self::protocol::*;
+
+mod template;
+pub use self::template::*;

src/telepathy/account.rs

@@ -0,0 +1,459 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account.xml -i org.freedesktop.Telepathy -o src/telepathy/account.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Account {
+    fn remove(&self) -> Result<(), tree::MethodErr>;
+    fn update_parameters(
+        &self,
+        set: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        unset: Vec<&str>,
+    ) -> Result<Vec<String>, tree::MethodErr>;
+    fn reconnect(&self) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn display_name(&self) -> Result<String, tree::MethodErr>;
+    fn set_display_name(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn icon(&self) -> Result<String, tree::MethodErr>;
+    fn set_icon(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn valid(&self) -> Result<bool, tree::MethodErr>;
+    fn enabled(&self) -> Result<bool, tree::MethodErr>;
+    fn set_enabled(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn nickname(&self) -> Result<String, tree::MethodErr>;
+    fn set_nickname(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn service(&self) -> Result<String, tree::MethodErr>;
+    fn set_service(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn parameters(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn automatic_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn set_automatic_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>;
+    fn connect_automatically(&self) -> Result<bool, tree::MethodErr>;
+    fn set_connect_automatically(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn connection(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn connection_status(&self) -> Result<u32, tree::MethodErr>;
+    fn connection_status_reason(&self) -> Result<u32, tree::MethodErr>;
+    fn connection_error(&self) -> Result<String, tree::MethodErr>;
+    fn connection_error_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn current_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn requested_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn set_requested_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>;
+    fn changing_presence(&self) -> Result<bool, tree::MethodErr>;
+    fn normalized_name(&self) -> Result<String, tree::MethodErr>;
+    fn has_been_online(&self) -> Result<bool, tree::MethodErr>;
+    fn supersedes(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn set_supersedes(&self, value: Vec<dbus::Path<'static>>) -> Result<(), tree::MethodErr>;
+}
+
+pub fn account_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Account,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.remove()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Remove", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let set: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let unset: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        let reconnect_required = d.update_parameters(set, unset)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(reconnect_required);
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateParameters", Default::default(), h);
+    let m = m.in_arg(("Set", "a{sv}"));
+    let m = m.in_arg(("Unset", "as"));
+    let m = m.out_arg(("Reconnect_Required", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.reconnect()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reconnect", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DisplayName", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.display_name()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_display_name(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Icon", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.icon()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_icon(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Valid", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.valid()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Enabled", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.enabled()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_enabled(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Nickname", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.nickname()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_nickname(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Service", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.service()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_service(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Parameters",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.parameters()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("AutomaticPresence", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.automatic_presence()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_automatic_presence(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ConnectAutomatically", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connect_automatically()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_connect_automatically(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Connection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ConnectionStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection_status()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ConnectionStatusReason", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection_status_reason()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ConnectionError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection_error()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "ConnectionErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection_error_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("CurrentPresence", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.current_presence()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("RequestedPresence", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.requested_presence()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_requested_presence(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ChangingPresence", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.changing_presence()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("NormalizedName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.normalized_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasBeenOnline", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.has_been_online()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Supersedes", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supersedes()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_supersedes(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Removed", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("AccountPropertyChanged", Default::default());
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountRemoved {}
+
+impl arg::AppendAll for AccountRemoved {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AccountRemoved {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountRemoved {})
+    }
+}
+
+impl dbus::message::SignalArgs for AccountRemoved {
+    const NAME: &'static str = "Removed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account";
+}
+
+#[derive(Debug)]
+pub struct AccountAccountPropertyChanged {
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for AccountAccountPropertyChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for AccountAccountPropertyChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountAccountPropertyChanged {
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountAccountPropertyChanged {
+    const NAME: &'static str = "AccountPropertyChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account";
+}

src/telepathy/account_interface_addressing.rs

@@ -0,0 +1,58 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_addressing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceAddressing {
+    fn set_urischeme_association(
+        &self,
+        urischeme: &str,
+        association: bool,
+    ) -> Result<(), tree::MethodErr>;
+    fn urischemes(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn account_interface_addressing_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AccountInterfaceAddressing,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.Addressing",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let urischeme: &str = i.read()?;
+        let association: bool = i.read()?;
+        let d = fclone(minfo);
+        d.set_urischeme_association(urischeme, association)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetURISchemeAssociation", Default::default(), h);
+    let m = m.in_arg(("URI_Scheme", "s"));
+    let m = m.in_arg(("Association", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("URISchemes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.urischemes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/account_interface_avatar.rs

@@ -0,0 +1,64 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Avatar.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_avatar.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceAvatar {
+    fn avatar(&self) -> Result<(Vec<u8>, String), tree::MethodErr>;
+    fn set_avatar(&self, value: (Vec<u8>, String)) -> Result<(), tree::MethodErr>;
+}
+
+pub fn account_interface_avatar_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AccountInterfaceAvatar,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Avatar", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(Vec<u8>, &str), _>("Avatar", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.avatar()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_avatar(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AvatarChanged", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountInterfaceAvatarAvatarChanged {}
+
+impl arg::AppendAll for AccountInterfaceAvatarAvatarChanged {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AccountInterfaceAvatarAvatarChanged {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountInterfaceAvatarAvatarChanged {})
+    }
+}
+
+impl dbus::message::SignalArgs for AccountInterfaceAvatarAvatarChanged {
+    const NAME: &'static str = "AvatarChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account.Interface.Avatar";
+}

src/telepathy/account_interface_external_password_storage.rs

@@ -0,0 +1,49 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_External_Password_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_external_password_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceExternalPasswordStorageDRAFT {
+    fn forget_password(&self) -> Result<(), tree::MethodErr>;
+    fn password_saved(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn account_interface_external_password_storage_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AccountInterfaceExternalPasswordStorageDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.ExternalPasswordStorage.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.forget_password()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ForgetPassword", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("PasswordSaved", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.password_saved()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/account_interface_hidden.rs

@@ -0,0 +1,38 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Hidden.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_hidden.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceHiddenDRAFT1 {
+    fn hidden(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn account_interface_hidden_draft1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AccountInterfaceHiddenDRAFT1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.Hidden.DRAFT1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<bool, _>("Hidden", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.hidden()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/account_interface_storage.rs

@@ -0,0 +1,83 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceStorage {
+    fn storage_provider(&self) -> Result<String, tree::MethodErr>;
+    fn storage_identifier(
+        &self,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn storage_specific_information(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn storage_restrictions(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn account_interface_storage_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AccountInterfaceStorage,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Storage", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("StorageProvider", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.storage_provider()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<arg::Variant<Box<dyn arg::RefArg>>, _>("StorageIdentifier", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.storage_identifier()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "StorageSpecificInformation",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.storage_specific_information()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("StorageRestrictions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.storage_restrictions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/account_manager.rs

@@ -0,0 +1,167 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager.xml -i org.freedesktop.Telepathy -o src/telepathy/account_manager.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountManager {
+    fn create_account(
+        &self,
+        connection_manager: &str,
+        protocol: &str,
+        display_name: &str,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn valid_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn invalid_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn supported_account_properties(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn account_manager_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AccountManager,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.AccountManager", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let connection_manager: &str = i.read()?;
+        let protocol: &str = i.read()?;
+        let display_name: &str = i.read()?;
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        let account = d.create_account(
+            connection_manager,
+            protocol,
+            display_name,
+            parameters,
+            properties,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(account);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateAccount", Default::default(), h);
+    let m = m.in_arg(("Connection_Manager", "s"));
+    let m = m.in_arg(("Protocol", "s"));
+    let m = m.in_arg(("Display_Name", "s"));
+    let m = m.in_arg(("Parameters", "a{sv}"));
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let m = m.out_arg(("Account", "o"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("ValidAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.valid_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InvalidAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.invalid_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedAccountProperties", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_account_properties()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AccountRemoved", Default::default());
+    let s = s.arg(("Account", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("AccountValidityChanged", Default::default());
+    let s = s.arg(("Account", "o"));
+    let s = s.arg(("Valid", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountManagerAccountRemoved {
+    pub account: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for AccountManagerAccountRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerAccountRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerAccountRemoved { account: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerAccountRemoved {
+    const NAME: &'static str = "AccountRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager";
+}
+
+#[derive(Debug)]
+pub struct AccountManagerAccountValidityChanged {
+    pub account: dbus::Path<'static>,
+    pub valid: bool,
+}
+
+impl arg::AppendAll for AccountManagerAccountValidityChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+        arg::RefArg::append(&self.valid, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerAccountValidityChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerAccountValidityChanged {
+            account: i.read()?,
+            valid: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerAccountValidityChanged {
+    const NAME: &'static str = "AccountValidityChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager";
+}

src/telepathy/account_manager_interface_hidden.rs

@@ -0,0 +1,111 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager_Interface_Hidden.xml -i org.freedesktop.Telepathy -o src/telepathy/account_manager_interface_hidden.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountManagerInterfaceHiddenDRAFT1 {
+    fn valid_hidden_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn invalid_hidden_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn account_manager_interface_hidden_draft1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AccountManagerInterfaceHiddenDRAFT1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<dbus::Path>, _>("ValidHiddenAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.valid_hidden_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InvalidHiddenAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.invalid_hidden_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("HiddenAccountRemoved", Default::default());
+    let s = s.arg(("Account", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("HiddenAccountValidityChanged", Default::default());
+    let s = s.arg(("Account", "o"));
+    let s = s.arg(("Valid", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    pub account: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { account: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    const NAME: &'static str = "HiddenAccountRemoved";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1";
+}
+
+#[derive(Debug)]
+pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    pub account: dbus::Path<'static>,
+    pub valid: bool,
+}
+
+impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+        arg::RefArg::append(&self.valid, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+                account: i.read()?,
+                valid: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    const NAME: &'static str = "HiddenAccountValidityChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1";
+}

src/telepathy/all.rs

@@ -0,0 +1,4 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/all.xml -i org.freedesktop.Telepathy -o src/telepathy/all.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;

src/telepathy/authentication_tls_certificate.rs

@@ -0,0 +1,175 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Authentication_TLS_Certificate.xml -i org.freedesktop.Telepathy -o src/telepathy/authentication_tls_certificate.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AuthenticationTLSCertificate {
+    fn accept(&self) -> Result<(), tree::MethodErr>;
+    fn reject(
+        &self,
+        rejections: Vec<(
+            u32,
+            &str,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+    ) -> Result<(), tree::MethodErr>;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+    fn rejections(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn certificate_type(&self) -> Result<String, tree::MethodErr>;
+    fn certificate_chain_data(&self) -> Result<Vec<Vec<u8>>, tree::MethodErr>;
+}
+
+pub fn authentication_tlscertificate_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AuthenticationTLSCertificate,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Authentication.TLSCertificate",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.accept()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let rejections: Vec<(
+            u32,
+            &str,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let d = fclone(minfo);
+        d.reject(rejections)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reject", Default::default(), h);
+    let m = m.in_arg(("Rejections", "a(usa{sv})"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("Rejections", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.rejections()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("CertificateType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.certificate_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<Vec<u8>>, _>("CertificateChainData", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.certificate_chain_data()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Accepted", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("Rejected", Default::default());
+    let s = s.arg(("Rejections", "a(usa{sv})"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AuthenticationTLSCertificateAccepted {}
+
+impl arg::AppendAll for AuthenticationTLSCertificateAccepted {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AuthenticationTLSCertificateAccepted {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AuthenticationTLSCertificateAccepted {})
+    }
+}
+
+impl dbus::message::SignalArgs for AuthenticationTLSCertificateAccepted {
+    const NAME: &'static str = "Accepted";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate";
+}
+
+#[derive(Debug)]
+pub struct AuthenticationTLSCertificateRejected {
+    pub rejections: Vec<(
+        u32,
+        String,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for AuthenticationTLSCertificateRejected {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.rejections, i);
+    }
+}
+
+impl arg::ReadAll for AuthenticationTLSCertificateRejected {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AuthenticationTLSCertificateRejected {
+            rejections: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AuthenticationTLSCertificateRejected {
+    const NAME: &'static str = "Rejected";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate";
+}

src/telepathy/call_content.rs

@@ -0,0 +1,151 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1Content {
+    fn remove(&self) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn name(&self) -> Result<String, tree::MethodErr>;
+    fn type_(&self) -> Result<u32, tree::MethodErr>;
+    fn disposition(&self) -> Result<u32, tree::MethodErr>;
+    fn streams(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn call1_content_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1Content,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Content", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.remove()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Remove", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Name", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Type", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.type_()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Disposition", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.disposition()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Streams", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.streams()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("StreamsAdded", Default::default());
+    let s = s.arg(("Streams", "ao"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamsRemoved", Default::default());
+    let s = s.arg(("Streams", "ao"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentStreamsAdded {
+    pub streams: Vec<dbus::Path<'static>>,
+}
+
+impl arg::AppendAll for Call1ContentStreamsAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.streams, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentStreamsAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentStreamsAdded { streams: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentStreamsAdded {
+    const NAME: &'static str = "StreamsAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentStreamsRemoved {
+    pub streams: Vec<dbus::Path<'static>>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1ContentStreamsRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.streams, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentStreamsRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentStreamsRemoved {
+            streams: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentStreamsRemoved {
+    const NAME: &'static str = "StreamsRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content";
+}

src/telepathy/call_content_interface_audio_control.rs

@@ -0,0 +1,78 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Audio_Control.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_audio_control.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceAudioControl {
+    fn report_input_volume(&self, volume: i32) -> Result<(), tree::MethodErr>;
+    fn report_output_volume(&self, volume: i32) -> Result<(), tree::MethodErr>;
+    fn requested_input_volume(&self) -> Result<i32, tree::MethodErr>;
+    fn requested_output_volume(&self) -> Result<i32, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_audio_control_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Call1ContentInterfaceAudioControl,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.AudioControl",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let volume: i32 = i.read()?;
+        let d = fclone(minfo);
+        d.report_input_volume(volume)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportInputVolume", Default::default(), h);
+    let m = m.in_arg(("Volume", "i"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let volume: i32 = i.read()?;
+        let d = fclone(minfo);
+        d.report_output_volume(volume)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportOutputVolume", Default::default(), h);
+    let m = m.in_arg(("Volume", "i"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<i32, _>("RequestedInputVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.requested_input_volume()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i32, _>("RequestedOutputVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.requested_output_volume()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/call_content_interface_dtmf.rs

@@ -0,0 +1,167 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_DTMF.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceDTMF {
+    fn start_tone(&self, event: u8) -> Result<(), tree::MethodErr>;
+    fn stop_tone(&self) -> Result<(), tree::MethodErr>;
+    fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>;
+    fn currently_sending_tones(&self) -> Result<bool, tree::MethodErr>;
+    fn deferred_tones(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_dtmf_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1ContentInterfaceDTMF,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let event: u8 = i.read()?;
+        let d = fclone(minfo);
+        d.start_tone(event)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartTone", Default::default(), h);
+    let m = m.in_arg(("Event", "y"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.stop_tone()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopTone", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tones: &str = i.read()?;
+        let d = fclone(minfo);
+        d.multiple_tones(tones)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("MultipleTones", Default::default(), h);
+    let m = m.in_arg(("Tones", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CurrentlySendingTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.currently_sending_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DeferredTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.deferred_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TonesDeferred", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("SendingTones", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("StoppedTones", Default::default());
+    let s = s.arg(("Cancelled", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFTonesDeferred {
+    pub tones: String,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFTonesDeferred {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFTonesDeferred {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFTonesDeferred { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFTonesDeferred {
+    const NAME: &'static str = "TonesDeferred";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFSendingTones {
+    pub tones: String,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFSendingTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFSendingTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFSendingTones { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFSendingTones {
+    const NAME: &'static str = "SendingTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFStoppedTones {
+    pub cancelled: bool,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFStoppedTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.cancelled, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFStoppedTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFStoppedTones {
+            cancelled: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFStoppedTones {
+    const NAME: &'static str = "StoppedTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}

src/telepathy/call_content_interface_media.rs

@@ -0,0 +1,350 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_media.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceMedia {
+    fn update_local_media_description(
+        &self,
+        media_description: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn acknowledge_dtmfchange(&self, event: u8, state: u32) -> Result<(), tree::MethodErr>;
+    fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn remote_media_descriptions(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        >,
+        tree::MethodErr,
+    >;
+    fn local_media_descriptions(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        >,
+        tree::MethodErr,
+    >;
+    fn media_description_offer(
+        &self,
+    ) -> Result<
+        (
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        ),
+        tree::MethodErr,
+    >;
+    fn packetization(&self) -> Result<u32, tree::MethodErr>;
+    fn current_dtmfevent(&self) -> Result<u8, tree::MethodErr>;
+    fn current_dtmfstate(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_media_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1ContentInterfaceMedia,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.Media",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let d = fclone(minfo);
+        d.update_local_media_description(media_description)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateLocalMediaDescription", Default::default(), h);
+    let m = m.in_arg(("MediaDescription", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let event: u8 = i.read()?;
+        let state: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.acknowledge_dtmfchange(event, state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcknowledgeDTMFChange", Default::default(), h);
+    let m = m.in_arg(("Event", "y"));
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let d = fclone(minfo);
+        d.fail(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Fail", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    >, _>("RemoteMediaDescriptions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_media_descriptions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    >, _>("LocalMediaDescriptions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_media_descriptions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ), _>("MediaDescriptionOffer", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.media_description_offer()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Packetization", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.packetization()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u8, _>("CurrentDTMFEvent", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.current_dtmfevent()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CurrentDTMFState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.current_dtmfstate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("NewMediaDescriptionOffer", Default::default());
+    let s = s.arg(("Media_Description", "o"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("MediaDescriptionOfferDone", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("LocalMediaDescriptionChanged", Default::default());
+    let s = s.arg(("Updated_Media_Description", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("RemoteMediaDescriptionsChanged", Default::default());
+    let s = s.arg(("Updated_Media_Descriptions", "a{ua{sv}}"));
+    let i = i.add_s(s);
+    let s = factory.signal("MediaDescriptionsRemoved", Default::default());
+    let s = s.arg(("Removed_Media_Descriptions", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("DTMFChangeRequested", Default::default());
+    let s = s.arg(("Event", "y"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    pub media_description: dbus::Path<'static>,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.media_description, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+            media_description: i.read()?,
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    const NAME: &'static str = "NewMediaDescriptionOffer";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaMediaDescriptionOfferDone {}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaMediaDescriptionOfferDone {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    const NAME: &'static str = "MediaDescriptionOfferDone";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    pub updated_media_description:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updated_media_description, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+            updated_media_description: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    const NAME: &'static str = "LocalMediaDescriptionChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    pub updated_media_descriptions: ::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    >,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updated_media_descriptions, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+            updated_media_descriptions: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    const NAME: &'static str = "RemoteMediaDescriptionsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    pub removed_media_descriptions: Vec<u32>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.removed_media_descriptions, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+            removed_media_descriptions: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    const NAME: &'static str = "MediaDescriptionsRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaDTMFChangeRequested {
+    pub event: u8,
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaDTMFChangeRequested {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.event, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaDTMFChangeRequested {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaDTMFChangeRequested {
+            event: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaDTMFChangeRequested {
+    const NAME: &'static str = "DTMFChangeRequested";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}

src/telepathy/call_content_interface_video_control.rs

@@ -0,0 +1,218 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Video_Control.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_video_control.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceVideoControl {
+    fn video_resolution(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn bitrate(&self) -> Result<u32, tree::MethodErr>;
+    fn framerate(&self) -> Result<u32, tree::MethodErr>;
+    fn mtu(&self) -> Result<u32, tree::MethodErr>;
+    fn manual_key_frames(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_video_control_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1ContentInterfaceVideoControl,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(u32, u32), _>("VideoResolution", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.video_resolution()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Bitrate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.bitrate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Framerate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.framerate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MTU", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.mtu()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ManualKeyFrames", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.manual_key_frames()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("KeyFrameRequested", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("VideoResolutionChanged", Default::default());
+    let s = s.arg(("NewResolution", "(uu)"));
+    let i = i.add_s(s);
+    let s = factory.signal("BitrateChanged", Default::default());
+    let s = s.arg(("NewBitrate", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("FramerateChanged", Default::default());
+    let s = s.arg(("NewFramerate", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MTUChanged", Default::default());
+    let s = s.arg(("NewMTU", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlKeyFrameRequested {}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlKeyFrameRequested {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    const NAME: &'static str = "KeyFrameRequested";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    pub new_resolution: (u32, u32),
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_resolution, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlVideoResolutionChanged {
+            new_resolution: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    const NAME: &'static str = "VideoResolutionChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlBitrateChanged {
+    pub new_bitrate: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlBitrateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_bitrate, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlBitrateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlBitrateChanged {
+            new_bitrate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlBitrateChanged {
+    const NAME: &'static str = "BitrateChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlFramerateChanged {
+    pub new_framerate: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlFramerateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_framerate, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlFramerateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlFramerateChanged {
+            new_framerate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlFramerateChanged {
+    const NAME: &'static str = "FramerateChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlMTUChanged {
+    pub new_mtu: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlMTUChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_mtu, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlMTUChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlMTUChanged { new_mtu: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlMTUChanged {
+    const NAME: &'static str = "MTUChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}

src/telepathy/call_content_media_description.rs

@@ -0,0 +1,155 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescription {
+    fn accept(
+        &self,
+        local_media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        >,
+    ) -> Result<(), tree::MethodErr>;
+    fn reject(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn further_negotiation_required(&self) -> Result<bool, tree::MethodErr>;
+    fn has_remote_information(&self) -> Result<bool, tree::MethodErr>;
+    fn codecs(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            u32,
+            bool,
+            ::std::collections::HashMap<String, String>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn remote_contact(&self) -> Result<u32, tree::MethodErr>;
+    fn ssrcs(&self) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Call1ContentMediaDescription,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let d = fclone(minfo);
+        d.accept(local_media_description)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let m = m.in_arg(("Local_Media_Description", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let d = fclone(minfo);
+        d.reject(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reject", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("FurtherNegotiationRequired", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.further_negotiation_required()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasRemoteInformation", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.has_remote_information()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        u32,
+        bool,
+        ::std::collections::HashMap<&str, &str>,
+    )>, _>("Codecs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.codecs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RemoteContact", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_contact()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, Vec<u32>>, _>("SSRCs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.ssrcs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs

@@ -0,0 +1,110 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Extended_Reports.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTCPExtendedReports {
+    fn loss_rlemax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn duplicate_rlemax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn packet_receipt_times_max_size(&self) -> Result<u32, tree::MethodErr>;
+    fn dlrrmax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn rttmode(&self) -> Result<u32, tree::MethodErr>;
+    fn statistics_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn enable_metrics(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtcpextended_reports_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Call1ContentMediaDescriptionInterfaceRTCPExtendedReports,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPExtendedReports",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("LossRLEMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.loss_rlemax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DuplicateRLEMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.duplicate_rlemax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("PacketReceiptTimesMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.packet_receipt_times_max_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DLRRMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.dlrrmax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RTTMode", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.rttmode()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("StatisticsFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.statistics_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("EnableMetrics", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.enable_metrics()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/call_content_media_description_interface_rtcp_feedback.rs

@@ -0,0 +1,59 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Feedback.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtcp_feedback.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTCPFeedback {
+    fn feedback_messages(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<u32, (u32, Vec<(String, String, String)>)>,
+        tree::MethodErr,
+    >;
+    fn does_avpf(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtcpfeedback_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Call1ContentMediaDescriptionInterfaceRTCPFeedback,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPFeedback",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory
+        .property::<::std::collections::HashMap<u32, (u32, Vec<(&str, &str, &str)>)>, _>(
+            "FeedbackMessages",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.feedback_messages()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("DoesAVPF", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.does_avpf()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs

@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTP_Header_Extensions.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions {
+    fn header_extensions(&self) -> Result<Vec<(u32, u32, String, String)>, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtpheader_extensions_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTPHeaderExtensions",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p =
+        factory.property::<Vec<(u32, u32, &str, &str)>, _>("HeaderExtensions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.header_extensions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/call_interface_mute.rs

@@ -0,0 +1,77 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Interface_Mute.xml -i org.freedesktop.Telepathy -o src/telepathy/call_interface_mute.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1InterfaceMute {
+    fn request_muted(&self, muted: bool) -> Result<(), tree::MethodErr>;
+    fn local_mute_state(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn call1_interface_mute_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1InterfaceMute,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Interface.Mute", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let muted: bool = i.read()?;
+        let d = fclone(minfo);
+        d.request_muted(muted)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestMuted", Default::default(), h);
+    let m = m.in_arg(("Muted", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("LocalMuteState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_mute_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("MuteStateChanged", Default::default());
+    let s = s.arg(("MuteState", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1InterfaceMuteMuteStateChanged {
+    pub mute_state: u32,
+}
+
+impl arg::AppendAll for Call1InterfaceMuteMuteStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.mute_state, i);
+    }
+}
+
+impl arg::ReadAll for Call1InterfaceMuteMuteStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1InterfaceMuteMuteStateChanged {
+            mute_state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1InterfaceMuteMuteStateChanged {
+    const NAME: &'static str = "MuteStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Interface.Mute";
+}

src/telepathy/call_stream.rs

@@ -0,0 +1,190 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1Stream {
+    fn set_sending(&self, send: bool) -> Result<(), tree::MethodErr>;
+    fn request_receiving(&self, contact: u32, receive: bool) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn remote_members(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn remote_member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn local_sending_state(&self) -> Result<u32, tree::MethodErr>;
+    fn can_request_receiving(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1Stream,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let send: bool = i.read()?;
+        let d = fclone(minfo);
+        d.set_sending(send)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSending", Default::default(), h);
+    let m = m.in_arg(("Send", "b"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contact: u32 = i.read()?;
+        let receive: bool = i.read()?;
+        let d = fclone(minfo);
+        d.request_receiving(contact, receive)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestReceiving", Default::default(), h);
+    let m = m.in_arg(("Contact", "u"));
+    let m = m.in_arg(("Receive", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("RemoteMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "RemoteMemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("LocalSendingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_sending_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanRequestReceiving", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_request_receiving()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("RemoteMembersChanged", Default::default());
+    let s = s.arg(("Updates", "a{uu}"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalSendingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamRemoteMembersChanged {
+    pub updates: ::std::collections::HashMap<u32, u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1StreamRemoteMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updates, i);
+        arg::RefArg::append(&self.identifiers, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamRemoteMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamRemoteMembersChanged {
+            updates: i.read()?,
+            identifiers: i.read()?,
+            removed: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamRemoteMembersChanged {
+    const NAME: &'static str = "RemoteMembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamLocalSendingStateChanged {
+    pub state: u32,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1StreamLocalSendingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamLocalSendingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamLocalSendingStateChanged {
+            state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamLocalSendingStateChanged {
+    const NAME: &'static str = "LocalSendingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream";
+}

src/telepathy/call_stream_endpoint.rs

@@ -0,0 +1,467 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Endpoint.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream_endpoint.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1StreamEndpoint {
+    fn set_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn set_endpoint_state_(&self, component: u32, state: u32) -> Result<(), tree::MethodErr>;
+    fn accept_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn reject_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn set_controlling_(&self, controlling: bool) -> Result<(), tree::MethodErr>;
+    fn remote_credentials(&self) -> Result<(String, String), tree::MethodErr>;
+    fn remote_candidates(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn selected_candidate_pairs(
+        &self,
+    ) -> Result<
+        Vec<(
+            (
+                u32,
+                String,
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            ),
+            (
+                u32,
+                String,
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            ),
+        )>,
+        tree::MethodErr,
+    >;
+    fn endpoint_state(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn transport(&self) -> Result<u32, tree::MethodErr>;
+    fn controlling(&self) -> Result<bool, tree::MethodErr>;
+    fn is_icelite(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_endpoint_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1StreamEndpoint,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream.Endpoint", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let d = fclone(minfo);
+        d.set_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let component: u32 = i.read()?;
+        let state: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.set_endpoint_state_(component, state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetEndpointState", Default::default(), h);
+    let m = m.in_arg(("Component", "u"));
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let d = fclone(minfo);
+        d.accept_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let d = fclone(minfo);
+        d.reject_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RejectSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let controlling: bool = i.read()?;
+        let d = fclone(minfo);
+        d.set_controlling_(controlling)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetControlling", Default::default(), h);
+    let m = m.in_arg(("Controlling", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<(&str, &str), _>("RemoteCredentials", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_credentials()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("RemoteCandidates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_candidates()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    )>, _>("SelectedCandidatePairs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.selected_candidate_pairs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("EndpointState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.endpoint_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Transport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Controlling", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.controlling()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("IsICELite", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.is_icelite()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("RemoteCredentialsSet", Default::default());
+    let s = s.arg(("Username", "s"));
+    let s = s.arg(("Password", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("RemoteCandidatesAdded", Default::default());
+    let s = s.arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("CandidatePairSelected", Default::default());
+    let s = s.arg(("Local_Candidate", "(usua{sv})"));
+    let s = s.arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("EndpointStateChanged", Default::default());
+    let s = s.arg(("Component", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("ControllingChanged", Default::default());
+    let s = s.arg(("Controlling", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointRemoteCredentialsSet {
+    pub username: String,
+    pub password: String,
+}
+
+impl arg::AppendAll for Call1StreamEndpointRemoteCredentialsSet {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.username, i);
+        arg::RefArg::append(&self.password, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointRemoteCredentialsSet {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointRemoteCredentialsSet {
+            username: i.read()?,
+            password: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCredentialsSet {
+    const NAME: &'static str = "RemoteCredentialsSet";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointRemoteCandidatesAdded {
+    pub candidates: Vec<(
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for Call1StreamEndpointRemoteCandidatesAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.candidates, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointRemoteCandidatesAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointRemoteCandidatesAdded {
+            candidates: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCandidatesAdded {
+    const NAME: &'static str = "RemoteCandidatesAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointCandidatePairSelected {
+    pub local_candidate: (
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    ),
+    pub remote_candidate: (
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    ),
+}
+
+impl arg::AppendAll for Call1StreamEndpointCandidatePairSelected {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.local_candidate, i);
+        arg::RefArg::append(&self.remote_candidate, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointCandidatePairSelected {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointCandidatePairSelected {
+            local_candidate: i.read()?,
+            remote_candidate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointCandidatePairSelected {
+    const NAME: &'static str = "CandidatePairSelected";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointEndpointStateChanged {
+    pub component: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamEndpointEndpointStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.component, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointEndpointStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointEndpointStateChanged {
+            component: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointEndpointStateChanged {
+    const NAME: &'static str = "EndpointStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointControllingChanged {
+    pub controlling: bool,
+}
+
+impl arg::AppendAll for Call1StreamEndpointControllingChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.controlling, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointControllingChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointControllingChanged {
+            controlling: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointControllingChanged {
+    const NAME: &'static str = "ControllingChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}

src/telepathy/call_stream_interface_media.rs

@@ -0,0 +1,550 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Interface_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream_interface_media.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1StreamInterfaceMedia {
+    fn complete_sending_state_change(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn report_sending_failure(
+        &self,
+        reason: u32,
+        error: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn complete_receiving_state_change(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn report_receiving_failure(
+        &self,
+        reason: u32,
+        error: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn set_credentials(&self, username: &str, password: &str) -> Result<(), tree::MethodErr>;
+    fn add_candidates(
+        &self,
+        candidates: Vec<(
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+    ) -> Result<(), tree::MethodErr>;
+    fn finish_initial_candidates(&self) -> Result<(), tree::MethodErr>;
+    fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn sending_state(&self) -> Result<u32, tree::MethodErr>;
+    fn receiving_state(&self) -> Result<u32, tree::MethodErr>;
+    fn transport(&self) -> Result<u32, tree::MethodErr>;
+    fn local_candidates(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn local_credentials(&self) -> Result<(String, String), tree::MethodErr>;
+    fn stunservers(&self) -> Result<Vec<(String, u16)>, tree::MethodErr>;
+    fn relay_info(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn has_server_info(&self) -> Result<bool, tree::MethodErr>;
+    fn endpoints(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn icerestart_pending(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_interface_media_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Call1StreamInterfaceMedia,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Stream.Interface.Media",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.complete_sending_state_change(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CompleteSendingStateChange", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let error: &str = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.report_sending_failure(reason, error, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportSendingFailure", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Error", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.complete_receiving_state_change(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CompleteReceivingStateChange", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let error: &str = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.report_receiving_failure(reason, error, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportReceivingFailure", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Error", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let username: &str = i.read()?;
+        let password: &str = i.read()?;
+        let d = fclone(minfo);
+        d.set_credentials(username, password)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetCredentials", Default::default(), h);
+    let m = m.in_arg(("Username", "s"));
+    let m = m.in_arg(("Password", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let candidates: Vec<(
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let d = fclone(minfo);
+        d.add_candidates(candidates)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddCandidates", Default::default(), h);
+    let m = m.in_arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.finish_initial_candidates()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("FinishInitialCandidates", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let d = fclone(minfo);
+        d.fail(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Fail", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("SendingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.sending_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ReceivingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.receiving_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Transport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("LocalCandidates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_candidates()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(&str, &str), _>("LocalCredentials", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_credentials()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(&str, u16)>, _>("STUNServers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.stunservers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "RelayInfo",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.relay_info()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasServerInfo", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.has_server_info()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Endpoints", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.endpoints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ICERestartPending", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.icerestart_pending()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SendingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("ReceivingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalCandidatesAdded", Default::default());
+    let s = s.arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalCredentialsChanged", Default::default());
+    let s = s.arg(("Username", "s"));
+    let s = s.arg(("Password", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("RelayInfoChanged", Default::default());
+    let s = s.arg(("Relay_Info", "aa{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("STUNServersChanged", Default::default());
+    let s = s.arg(("Servers", "a(sq)"));
+    let i = i.add_s(s);
+    let s = factory.signal("ServerInfoRetrieved", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("EndpointsChanged", Default::default());
+    let s = s.arg(("Endpoints_Added", "ao"));
+    let s = s.arg(("Endpoints_Removed", "ao"));
+    let i = i.add_s(s);
+    let s = factory.signal("ICERestartRequested", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaSendingStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaSendingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaSendingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaSendingStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSendingStateChanged {
+    const NAME: &'static str = "SendingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaReceivingStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaReceivingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaReceivingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaReceivingStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaReceivingStateChanged {
+    const NAME: &'static str = "ReceivingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaLocalCandidatesAdded {
+    pub candidates: Vec<(
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.candidates, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaLocalCandidatesAdded {
+            candidates: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    const NAME: &'static str = "LocalCandidatesAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaLocalCredentialsChanged {
+    pub username: String,
+    pub password: String,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.username, i);
+        arg::RefArg::append(&self.password, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaLocalCredentialsChanged {
+            username: i.read()?,
+            password: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    const NAME: &'static str = "LocalCredentialsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaRelayInfoChanged {
+    pub relay_info:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaRelayInfoChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.relay_info, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaRelayInfoChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaRelayInfoChanged {
+            relay_info: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaRelayInfoChanged {
+    const NAME: &'static str = "RelayInfoChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaSTUNServersChanged {
+    pub servers: Vec<(String, u16)>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaSTUNServersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.servers, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaSTUNServersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaSTUNServersChanged { servers: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSTUNServersChanged {
+    const NAME: &'static str = "STUNServersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaServerInfoRetrieved {}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaServerInfoRetrieved {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaServerInfoRetrieved {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaServerInfoRetrieved {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaServerInfoRetrieved {
+    const NAME: &'static str = "ServerInfoRetrieved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaEndpointsChanged {
+    pub endpoints_added: Vec<dbus::Path<'static>>,
+    pub endpoints_removed: Vec<dbus::Path<'static>>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaEndpointsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.endpoints_added, i);
+        arg::RefArg::append(&self.endpoints_removed, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaEndpointsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaEndpointsChanged {
+            endpoints_added: i.read()?,
+            endpoints_removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaEndpointsChanged {
+    const NAME: &'static str = "EndpointsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaICERestartRequested {}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaICERestartRequested {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaICERestartRequested {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaICERestartRequested {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaICERestartRequested {
+    const NAME: &'static str = "ICERestartRequested";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}

src/telepathy/channel.rs

@@ -0,0 +1,192 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel.xml -i org.freedesktop.Telepathy -o src/telepathy/channel.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Channel {
+    fn close(&self) -> Result<(), tree::MethodErr>;
+    fn get_channel_type(&self) -> Result<String, tree::MethodErr>;
+    fn get_handle(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn get_interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn channel_type(&self) -> Result<String, tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn target_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn target_id(&self) -> Result<String, tree::MethodErr>;
+    fn target_handle_type(&self) -> Result<u32, tree::MethodErr>;
+    fn requested(&self) -> Result<bool, tree::MethodErr>;
+    fn initiator_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn initiator_id(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Channel,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.close()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Close", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let channel_type = d.get_channel_type()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(channel_type);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetChannelType", Default::default(), h);
+    let m = m.out_arg(("Channel_Type", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let (target_handle_type, target_handle) = d.get_handle()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(target_handle_type);
+        let rm = rm.append1(target_handle);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHandle", Default::default(), h);
+    let m = m.out_arg(("Target_Handle_Type", "u"));
+    let m = m.out_arg(("Target_Handle", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let interfaces = d.get_interfaces()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(interfaces);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetInterfaces", Default::default(), h);
+    let m = m.out_arg(("Interfaces", "as"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("ChannelType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.channel_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("TargetHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("TargetHandleType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_handle_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Requested", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.requested()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("InitiatorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initiator_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitiatorID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initiator_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Closed", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelClosed {}
+
+impl arg::AppendAll for ChannelClosed {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelClosed {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelClosed {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelClosed {
+    const NAME: &'static str = "Closed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel";
+}

src/telepathy/channel_bundle.rs

@@ -0,0 +1,35 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Bundle.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_bundle.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelBundleDRAFT {
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn channel_bundle_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelBundleDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelBundle.DRAFT", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_dispatch_operation.rs

@@ -0,0 +1,192 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatch_Operation.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatch_operation.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatchOperation {
+    fn handle_with(&self, handler: &str) -> Result<(), tree::MethodErr>;
+    fn claim(&self) -> Result<(), tree::MethodErr>;
+    fn handle_with_time(&self, handler: &str, user_action_time: i64)
+        -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn connection(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn account(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn channels(
+        &self,
+    ) -> Result<
+        Vec<(
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn possible_handlers(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn channel_dispatch_operation_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelDispatchOperation,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatchOperation", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handler: &str = i.read()?;
+        let d = fclone(minfo);
+        d.handle_with(handler)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleWith", Default::default(), h);
+    let m = m.in_arg(("Handler", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.claim()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Claim", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handler: &str = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let d = fclone(minfo);
+        d.handle_with_time(handler, user_action_time)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleWithTime", Default::default(), h);
+    let m = m.in_arg(("Handler", "s"));
+    let m = m.in_arg(("UserActionTime", "x"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Connection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.connection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Account", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.account()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("Channels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("PossibleHandlers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.possible_handlers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChannelLost", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("Finished", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatchOperationChannelLost {
+    pub channel: dbus::Path<'static>,
+    pub error: String,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelDispatchOperationChannelLost {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatchOperationChannelLost {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelDispatchOperationChannelLost {
+            channel: i.read()?,
+            error: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatchOperationChannelLost {
+    const NAME: &'static str = "ChannelLost";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation";
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatchOperationFinished {}
+
+impl arg::AppendAll for ChannelDispatchOperationFinished {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelDispatchOperationFinished {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelDispatchOperationFinished {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatchOperationFinished {
+    const NAME: &'static str = "Finished";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation";
+}

src/telepathy/channel_dispatcher.rs

@@ -0,0 +1,255 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcher {
+    fn create_channel(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn ensure_channel(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn create_channel_with_hints(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+        hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn ensure_channel_with_hints(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+        hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn delegate_channels(
+        &self,
+        channels: Vec<dbus::Path>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<
+        (
+            Vec<dbus::Path<'static>>,
+            ::std::collections::HashMap<dbus::Path<'static>, (String, String)>,
+        ),
+        tree::MethodErr,
+    >;
+    fn present_channel(
+        &self,
+        channel: dbus::Path,
+        user_action_time: i64,
+    ) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn supports_request_hints(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_dispatcher_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelDispatcher,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatcher", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let d = fclone(minfo);
+        let request = d.create_channel(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateChannel", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let d = fclone(minfo);
+        let request = d.ensure_channel(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("EnsureChannel", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        let request = d.create_channel_with_hints(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+            hints,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateChannelWithHints", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.in_arg(("Hints", "a{sv}"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        let request = d.ensure_channel_with_hints(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+            hints,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("EnsureChannelWithHints", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.in_arg(("Hints", "a{sv}"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channels: Vec<dbus::Path> = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let d = fclone(minfo);
+        let (delegated, not_delegated) =
+            d.delegate_channels(channels, user_action_time, preferred_handler)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(delegated);
+        let rm = rm.append1(not_delegated);
+        Ok(vec![rm])
+    };
+    let m = factory.method("DelegateChannels", Default::default(), h);
+    let m = m.in_arg(("Channels", "ao"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Delegated", "ao"));
+    let m = m.out_arg(("Not_Delegated", "a{o(ss)}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: dbus::Path = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let d = fclone(minfo);
+        d.present_channel(channel, user_action_time)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("PresentChannel", Default::default(), h);
+    let m = m.in_arg(("Channel", "o"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("SupportsRequestHints", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supports_request_hints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_dispatcher_interface_messages1.rs

@@ -0,0 +1,54 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Messages1.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher_interface_messages1.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcherInterfaceMessages1 {
+    fn send_message(
+        &self,
+        account: dbus::Path,
+        target_id: &str,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+        flags: u32,
+    ) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_dispatcher_interface_messages1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelDispatcherInterfaceMessages1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.Messages1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let target_id: &str = i.read()?;
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let flags: u32 = i.read()?;
+        let d = fclone(minfo);
+        let token = d.send_message(account, target_id, message, flags)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(token);
+        Ok(vec![rm])
+    };
+    let m = factory.method("SendMessage", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Target_ID", "s"));
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.in_arg(("Flags", "u"));
+    let m = m.out_arg(("Token", "s"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_dispatcher_interface_operation_list.rs

@@ -0,0 +1,117 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Operation_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher_interface_operation_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcherInterfaceOperationList {
+    fn dispatch_operations(
+        &self,
+    ) -> Result<
+        Vec<(
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_dispatcher_interface_operation_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelDispatcherInterfaceOperationList,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("DispatchOperations", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.dispatch_operations()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("NewDispatchOperation", Default::default());
+    let s = s.arg(("Dispatch_Operation", "o"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("DispatchOperationFinished", Default::default());
+    let s = s.arg(("Dispatch_Operation", "o"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    pub dispatch_operation: dbus::Path<'static>,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.dispatch_operation, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+                dispatch_operation: i.read()?,
+                properties: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    const NAME: &'static str = "NewDispatchOperation";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList";
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    pub dispatch_operation: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.dispatch_operation, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+                dispatch_operation: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs
+    for ChannelDispatcherInterfaceOperationListDispatchOperationFinished
+{
+    const NAME: &'static str = "DispatchOperationFinished";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList";
+}

src/telepathy/channel_future.rs

@@ -0,0 +1,35 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Future.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_future.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelFUTURE {
+    fn bundle(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+}
+
+pub fn channel_future_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelFUTURE,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.FUTURE", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<dbus::Path, _>("Bundle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.bundle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_handler.rs

@@ -0,0 +1,61 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_handler.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelHandler {
+    fn handle_channel(
+        &self,
+        bus_name: &str,
+        connection: dbus::Path,
+        channel_type: &str,
+        channel: dbus::Path,
+        handle_type: u32,
+        handle: u32,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_handler_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelHandler,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelHandler", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let bus_name: &str = i.read()?;
+        let connection: dbus::Path = i.read()?;
+        let channel_type: &str = i.read()?;
+        let channel: dbus::Path = i.read()?;
+        let handle_type: u32 = i.read()?;
+        let handle: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.handle_channel(
+            bus_name,
+            connection,
+            channel_type,
+            channel,
+            handle_type,
+            handle,
+        )?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleChannel", Default::default(), h);
+    let m = m.in_arg(("Bus_Name", "s"));
+    let m = m.in_arg(("Connection", "o"));
+    let m = m.in_arg(("Channel_Type", "s"));
+    let m = m.in_arg(("Channel", "o"));
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handle", "u"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_addressing.rs

@@ -0,0 +1,74 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_addressing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceAddressing1 {
+    fn target_vcard_field(&self) -> Result<String, tree::MethodErr>;
+    fn target_urischeme(&self) -> Result<String, tree::MethodErr>;
+    fn target_vcard_address(&self) -> Result<String, tree::MethodErr>;
+    fn target_uri(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_addressing1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceAddressing1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Addressing1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("TargetVCardField", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_vcard_field()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetURIScheme", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_urischeme()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetVCardAddress", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_vcard_address()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetURI", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.target_uri()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_anonymity.rs

@@ -0,0 +1,62 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Anonymity.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_anonymity.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceAnonymity {
+    fn anonymity_modes(&self) -> Result<u32, tree::MethodErr>;
+    fn anonymity_mandatory(&self) -> Result<bool, tree::MethodErr>;
+    fn anonymous_id(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_anonymity_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceAnonymity,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Anonymity",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("AnonymityModes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymity_modes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("AnonymityMandatory", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymity_mandatory()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("AnonymousID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymous_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_call_state.rs

@@ -0,0 +1,70 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Call_State.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_call_state.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCallState {
+    fn get_call_states(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+}
+
+pub fn channel_interface_call_state_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceCallState,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CallState",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let states = d.get_call_states()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(states);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCallStates", Default::default(), h);
+    let m = m.out_arg(("States", "a{uu}"));
+    let i = i.add_m(m);
+    let s = factory.signal("CallStateChanged", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceCallStateCallStateChanged {
+    pub contact: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceCallStateCallStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceCallStateCallStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceCallStateCallStateChanged {
+            contact: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceCallStateCallStateChanged {
+    const NAME: &'static str = "CallStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.CallState";
+}

src/telepathy/channel_interface_captcha_authentication.rs

@@ -0,0 +1,153 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Captcha_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_captcha_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCaptchaAuthentication1 {
+    fn get_captchas(
+        &self,
+    ) -> Result<(Vec<(u32, String, String, u32, Vec<String>)>, u32, String), tree::MethodErr>;
+    fn get_captcha_data(&self, id: u32, mime_type: &str) -> Result<Vec<u8>, tree::MethodErr>;
+    fn answer_captchas(
+        &self,
+        answers: ::std::collections::HashMap<u32, &str>,
+    ) -> Result<(), tree::MethodErr>;
+    fn cancel_captcha(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>;
+    fn can_retry_captcha(&self) -> Result<bool, tree::MethodErr>;
+    fn captcha_status(&self) -> Result<u32, tree::MethodErr>;
+    fn captcha_error(&self) -> Result<String, tree::MethodErr>;
+    fn captcha_error_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_interface_captcha_authentication1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceCaptchaAuthentication1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let (captcha_info, number_required, language) = d.get_captchas()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(captcha_info);
+        let rm = rm.append1(number_required);
+        let rm = rm.append1(language);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCaptchas", Default::default(), h);
+    let m = m.out_arg(("Captcha_Info", "a(ussuas)"));
+    let m = m.out_arg(("Number_Required", "u"));
+    let m = m.out_arg(("Language", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let mime_type: &str = i.read()?;
+        let d = fclone(minfo);
+        let captcha_data = d.get_captcha_data(id, mime_type)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(captcha_data);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCaptchaData", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.in_arg(("Mime_Type", "s"));
+    let m = m.out_arg(("Captcha_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let answers: ::std::collections::HashMap<u32, &str> = i.read()?;
+        let d = fclone(minfo);
+        d.answer_captchas(answers)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AnswerCaptchas", Default::default(), h);
+    let m = m.in_arg(("Answers", "a{us}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let debug_message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.cancel_captcha(reason, debug_message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CancelCaptcha", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Debug_Message", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CanRetryCaptcha", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_retry_captcha()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CaptchaStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.captcha_status()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("CaptchaError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.captcha_error()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "CaptchaErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.captcha_error_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_chat_state.rs

@@ -0,0 +1,85 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Chat_State.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_chat_state.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceChatState {
+    fn set_chat_state(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn chat_states(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+}
+
+pub fn channel_interface_chat_state_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceChatState,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.ChatState",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.set_chat_state(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetChatState", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("ChatStates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.chat_states()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChatStateChanged", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceChatStateChatStateChanged {
+    pub contact: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceChatStateChatStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceChatStateChatStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceChatStateChatStateChanged {
+            contact: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceChatStateChatStateChanged {
+    const NAME: &'static str = "ChatStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ChatState";
+}

src/telepathy/channel_interface_conference.rs

@@ -0,0 +1,171 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Conference.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_conference.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceConference {
+    fn channels(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn initial_channels(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn initial_invitee_handles(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn initial_invitee_ids(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn invitation_message(&self) -> Result<String, tree::MethodErr>;
+    fn original_channels(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn channel_interface_conference_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceConference,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Conference",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<dbus::Path>, _>("Channels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InitialChannels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("InitialInviteeHandles", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_invitee_handles()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("InitialInviteeIDs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_invitee_ids()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InvitationMessage", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.invitation_message()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, dbus::Path>, _>(
+        "OriginalChannels",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.original_channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChannelMerged", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Channel_Specific_Handle", "u"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("ChannelRemoved", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceConferenceChannelMerged {
+    pub channel: dbus::Path<'static>,
+    pub channel_specific_handle: u32,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceConferenceChannelMerged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.channel_specific_handle, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceConferenceChannelMerged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceConferenceChannelMerged {
+            channel: i.read()?,
+            channel_specific_handle: i.read()?,
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelMerged {
+    const NAME: &'static str = "ChannelMerged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceConferenceChannelRemoved {
+    pub channel: dbus::Path<'static>,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceConferenceChannelRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceConferenceChannelRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceConferenceChannelRemoved {
+            channel: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelRemoved {
+    const NAME: &'static str = "ChannelRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference";
+}

src/telepathy/channel_interface_credentials_storage.rs

@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Credentials_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_credentials_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCredentialsStorageDRAFT {
+    fn store_credentials(&self, store: bool) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_credentials_storage_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceCredentialsStorageDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CredentialsStorage.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let store: bool = i.read()?;
+        let d = fclone(minfo);
+        d.store_credentials(store)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StoreCredentials", Default::default(), h);
+    let m = m.in_arg(("Store", "b"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_destroyable.rs

@@ -0,0 +1,36 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Destroyable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_destroyable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceDestroyable {
+    fn destroy(&self) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_destroyable_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceDestroyable,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Destroyable",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.destroy()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Destroy", Default::default(), h);
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_dtmf.rs

@@ -0,0 +1,181 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_DTMF.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceDTMF {
+    fn start_tone(&self, stream_id: u32, event: u8) -> Result<(), tree::MethodErr>;
+    fn stop_tone(&self, stream_id: u32) -> Result<(), tree::MethodErr>;
+    fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>;
+    fn currently_sending_tones(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_tones(&self) -> Result<String, tree::MethodErr>;
+    fn deferred_tones(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_dtmf_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceDTMF,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.DTMF", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let stream_id: u32 = i.read()?;
+        let event: u8 = i.read()?;
+        let d = fclone(minfo);
+        d.start_tone(stream_id, event)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartTone", Default::default(), h);
+    let m = m.in_arg(("Stream_ID", "u"));
+    let m = m.in_arg(("Event", "y"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let stream_id: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.stop_tone(stream_id)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopTone", Default::default(), h);
+    let m = m.in_arg(("Stream_ID", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tones: &str = i.read()?;
+        let d = fclone(minfo);
+        d.multiple_tones(tones)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("MultipleTones", Default::default(), h);
+    let m = m.in_arg(("Tones", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CurrentlySendingTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.currently_sending_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DeferredTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.deferred_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TonesDeferred", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("SendingTones", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("StoppedTones", Default::default());
+    let s = s.arg(("Cancelled", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFTonesDeferred {
+    pub tones: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFTonesDeferred {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFTonesDeferred {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFTonesDeferred { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFTonesDeferred {
+    const NAME: &'static str = "TonesDeferred";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFSendingTones {
+    pub tones: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFSendingTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFSendingTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFSendingTones { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFSendingTones {
+    const NAME: &'static str = "SendingTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFStoppedTones {
+    pub cancelled: bool,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFStoppedTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.cancelled, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFStoppedTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFStoppedTones {
+            cancelled: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFStoppedTones {
+    const NAME: &'static str = "StoppedTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}

src/telepathy/channel_interface_file_transfer_metadata.rs

@@ -0,0 +1,73 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_File_Transfer_Metadata.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_file_transfer_metadata.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceFileTransferMetadata {
+    fn service_name(&self) -> Result<String, tree::MethodErr>;
+    fn set_service_name(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn metadata(&self)
+        -> Result<::std::collections::HashMap<String, Vec<String>>, tree::MethodErr>;
+    fn set_metadata(
+        &self,
+        value: ::std::collections::HashMap<String, Vec<String>>,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_file_transfer_metadata_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceFileTransferMetadata,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("ServiceName", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.service_name()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_service_name(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<&str, Vec<&str>>, _>(
+        "Metadata",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.metadata()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_metadata(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_group.rs

@@ -0,0 +1,532 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Group.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_group.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceGroup {
+    fn add_members(&self, contacts: Vec<u32>, message: &str) -> Result<(), tree::MethodErr>;
+    fn get_all_members(&self) -> Result<(Vec<u32>, Vec<u32>, Vec<u32>), tree::MethodErr>;
+    fn get_group_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn get_handle_owners(&self, handles: Vec<u32>) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_local_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_local_pending_members_with_info(
+        &self,
+    ) -> Result<Vec<(u32, u32, u32, String)>, tree::MethodErr>;
+    fn get_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_remote_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn remove_members(&self, contacts: Vec<u32>, message: &str) -> Result<(), tree::MethodErr>;
+    fn remove_members_with_reason(
+        &self,
+        contacts: Vec<u32>,
+        message: &str,
+        reason: u32,
+    ) -> Result<(), tree::MethodErr>;
+    fn group_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn handle_owners(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn local_pending_members(&self) -> Result<Vec<(u32, u32, u32, String)>, tree::MethodErr>;
+    fn members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn remote_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+}
+
+pub fn channel_interface_group_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceGroup,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Group", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.add_members(contacts, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddMembers", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let (members, local_pending, remote_pending) = d.get_all_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(members);
+        let rm = rm.append1(local_pending);
+        let rm = rm.append1(remote_pending);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAllMembers", Default::default(), h);
+    let m = m.out_arg(("Members", "au"));
+    let m = m.out_arg(("Local_Pending", "au"));
+    let m = m.out_arg(("Remote_Pending", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let group_flags = d.get_group_flags()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(group_flags);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetGroupFlags", Default::default(), h);
+    let m = m.out_arg(("Group_Flags", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handles: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let owners = d.get_handle_owners(handles)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(owners);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHandleOwners", Default::default(), h);
+    let m = m.in_arg(("Handles", "au"));
+    let m = m.out_arg(("Owners", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let handles = d.get_local_pending_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetLocalPendingMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let info = d.get_local_pending_members_with_info()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(info);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetLocalPendingMembersWithInfo", Default::default(), h);
+    let m = m.out_arg(("Info", "a(uuus)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let handles = d.get_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let handles = d.get_remote_pending_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetRemotePendingMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let self_handle = d.get_self_handle()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(self_handle);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSelfHandle", Default::default(), h);
+    let m = m.out_arg(("Self_Handle", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.remove_members(contacts, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveMembers", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let reason: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.remove_members_with_reason(contacts, message, reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveMembersWithReason", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let m = m.in_arg(("Reason", "u"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("GroupFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.group_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("HandleOwners", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.handle_owners()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<(u32, u32, u32, &str)>, _>("LocalPendingMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.local_pending_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("Members", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("RemotePendingMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.remote_pending_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SelfHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.self_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "MemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("HandleOwnersChanged", Default::default());
+    let s = s.arg(("Added", "a{uu}"));
+    let s = s.arg(("Removed", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("HandleOwnersChangedDetailed", Default::default());
+    let s = s.arg(("Added", "a{uu}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let i = i.add_s(s);
+    let s = factory.signal("SelfHandleChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("SelfContactChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let s = s.arg(("Self_ID", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("GroupFlagsChanged", Default::default());
+    let s = s.arg(("Added", "u"));
+    let s = s.arg(("Removed", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MembersChanged", Default::default());
+    let s = s.arg(("Message", "s"));
+    let s = s.arg(("Added", "au"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Local_Pending", "au"));
+    let s = s.arg(("Remote_Pending", "au"));
+    let s = s.arg(("Actor", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MembersChangedDetailed", Default::default());
+    let s = s.arg(("Added", "au"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Local_Pending", "au"));
+    let s = s.arg(("Remote_Pending", "au"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupHandleOwnersChanged {
+    pub added: ::std::collections::HashMap<u32, u32>,
+    pub removed: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupHandleOwnersChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChanged {
+    const NAME: &'static str = "HandleOwnersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    pub added: ::std::collections::HashMap<u32, u32>,
+    pub removed: Vec<u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.identifiers, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupHandleOwnersChangedDetailed {
+            added: i.read()?,
+            removed: i.read()?,
+            identifiers: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    const NAME: &'static str = "HandleOwnersChangedDetailed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupSelfHandleChanged {
+    pub self_handle: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupSelfHandleChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupSelfHandleChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupSelfHandleChanged {
+            self_handle: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfHandleChanged {
+    const NAME: &'static str = "SelfHandleChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupSelfContactChanged {
+    pub self_handle: u32,
+    pub self_id: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupSelfContactChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+        arg::RefArg::append(&self.self_id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupSelfContactChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupSelfContactChanged {
+            self_handle: i.read()?,
+            self_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfContactChanged {
+    const NAME: &'static str = "SelfContactChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupGroupFlagsChanged {
+    pub added: u32,
+    pub removed: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupGroupFlagsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupGroupFlagsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupGroupFlagsChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupGroupFlagsChanged {
+    const NAME: &'static str = "GroupFlagsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupMembersChanged {
+    pub message: String,
+    pub added: Vec<u32>,
+    pub removed: Vec<u32>,
+    pub local_pending: Vec<u32>,
+    pub remote_pending: Vec<u32>,
+    pub actor: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message, i);
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.local_pending, i);
+        arg::RefArg::append(&self.remote_pending, i);
+        arg::RefArg::append(&self.actor, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupMembersChanged {
+            message: i.read()?,
+            added: i.read()?,
+            removed: i.read()?,
+            local_pending: i.read()?,
+            remote_pending: i.read()?,
+            actor: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChanged {
+    const NAME: &'static str = "MembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupMembersChangedDetailed {
+    pub added: Vec<u32>,
+    pub removed: Vec<u32>,
+    pub local_pending: Vec<u32>,
+    pub remote_pending: Vec<u32>,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupMembersChangedDetailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.local_pending, i);
+        arg::RefArg::append(&self.remote_pending, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupMembersChangedDetailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupMembersChangedDetailed {
+            added: i.read()?,
+            removed: i.read()?,
+            local_pending: i.read()?,
+            remote_pending: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChangedDetailed {
+    const NAME: &'static str = "MembersChangedDetailed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}

src/telepathy/channel_interface_hold.rs

@@ -0,0 +1,83 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Hold.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_hold.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceHold {
+    fn get_hold_state(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn request_hold(&self, hold: bool) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_hold_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceHold,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Hold", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let (hold_state, reason) = d.get_hold_state()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(hold_state);
+        let rm = rm.append1(reason);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHoldState", Default::default(), h);
+    let m = m.out_arg(("HoldState", "u"));
+    let m = m.out_arg(("Reason", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let hold: bool = i.read()?;
+        let d = fclone(minfo);
+        d.request_hold(hold)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestHold", Default::default(), h);
+    let m = m.in_arg(("Hold", "b"));
+    let i = i.add_m(m);
+    let s = factory.signal("HoldStateChanged", Default::default());
+    let s = s.arg(("HoldState", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceHoldHoldStateChanged {
+    pub hold_state: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceHoldHoldStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.hold_state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceHoldHoldStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceHoldHoldStateChanged {
+            hold_state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceHoldHoldStateChanged {
+    const NAME: &'static str = "HoldStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Hold";
+}

src/telepathy/channel_interface_html.rs

@@ -0,0 +1,25 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_HTML.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_html.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceHTMLDRAFT {}
+
+pub fn channel_interface_htmldraft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceHTMLDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.HTML.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    i
+}

src/telepathy/channel_interface_media_signalling.rs

@@ -0,0 +1,70 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Media_Signalling.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_media_signalling.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMediaSignalling {
+    fn get_session_handlers(&self) -> Result<Vec<(dbus::Path<'static>, String)>, tree::MethodErr>;
+}
+
+pub fn channel_interface_media_signalling_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceMediaSignalling,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let session_handlers = d.get_session_handlers()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(session_handlers);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSessionHandlers", Default::default(), h);
+    let m = m.out_arg(("Session_Handlers", "a(os)"));
+    let i = i.add_m(m);
+    let s = factory.signal("NewSessionHandler", Default::default());
+    let s = s.arg(("Session_Handler", "o"));
+    let s = s.arg(("Session_Type", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMediaSignallingNewSessionHandler {
+    pub session_handler: dbus::Path<'static>,
+    pub session_type: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceMediaSignallingNewSessionHandler {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.session_handler, i);
+        arg::RefArg::append(&self.session_type, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMediaSignallingNewSessionHandler {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMediaSignallingNewSessionHandler {
+            session_handler: i.read()?,
+            session_type: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMediaSignallingNewSessionHandler {
+    const NAME: &'static str = "NewSessionHandler";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
+}

src/telepathy/channel_interface_mergeable_conference.rs

@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Mergeable_Conference.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_mergeable_conference.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMergeableConferenceDRAFT {
+    fn merge(&self, channel: dbus::Path) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_mergeable_conference_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceMergeableConferenceDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.MergeableConference.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: dbus::Path = i.read()?;
+        let d = fclone(minfo);
+        d.merge(channel)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Merge", Default::default(), h);
+    let m = m.in_arg(("Channel", "o"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_messages.rs

@@ -0,0 +1,226 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Messages.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_messages.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMessages {
+    fn send_message(
+        &self,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+        flags: u32,
+    ) -> Result<String, tree::MethodErr>;
+    fn get_pending_message_content(
+        &self,
+        message_id: u32,
+        parts: Vec<u32>,
+    ) -> Result<
+        ::std::collections::HashMap<u32, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn supported_content_types(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn message_types(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn message_part_support_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn pending_messages(
+        &self,
+    ) -> Result<
+        Vec<Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>>,
+        tree::MethodErr,
+    >;
+    fn delivery_reporting_support(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_messages_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceMessages,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Messages", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let flags: u32 = i.read()?;
+        let d = fclone(minfo);
+        let token = d.send_message(message, flags)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(token);
+        Ok(vec![rm])
+    };
+    let m = factory.method("SendMessage", Default::default(), h);
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.in_arg(("Flags", "u"));
+    let m = m.out_arg(("Token", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message_id: u32 = i.read()?;
+        let parts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let content = d.get_pending_message_content(message_id, parts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(content);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetPendingMessageContent", Default::default(), h);
+    let m = m.in_arg(("Message_ID", "u"));
+    let m = m.in_arg(("Parts", "au"));
+    let m = m.out_arg(("Content", "a{uv}"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedContentTypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_content_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("MessageTypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MessagePartSupportFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_part_support_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>>, _>("PendingMessages", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.pending_messages()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DeliveryReportingSupport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.delivery_reporting_support()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("MessageSent", Default::default());
+    let s = s.arg(("Content", "aa{sv}"));
+    let s = s.arg(("Flags", "u"));
+    let s = s.arg(("Message_Token", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("PendingMessagesRemoved", Default::default());
+    let s = s.arg(("Message_IDs", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("MessageReceived", Default::default());
+    let s = s.arg(("Message", "aa{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesMessageSent {
+    pub content:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+    pub flags: u32,
+    pub message_token: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesMessageSent {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+        arg::RefArg::append(&self.flags, i);
+        arg::RefArg::append(&self.message_token, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesMessageSent {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesMessageSent {
+            content: i.read()?,
+            flags: i.read()?,
+            message_token: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageSent {
+    const NAME: &'static str = "MessageSent";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesPendingMessagesRemoved {
+    pub message_ids: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesPendingMessagesRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message_ids, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesPendingMessagesRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesPendingMessagesRemoved {
+            message_ids: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesPendingMessagesRemoved {
+    const NAME: &'static str = "PendingMessagesRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesMessageReceived {
+    pub message:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesMessageReceived {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesMessageReceived {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesMessageReceived { message: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageReceived {
+    const NAME: &'static str = "MessageReceived";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}

src/telepathy/channel_interface_password.rs

@@ -0,0 +1,83 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Password.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_password.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfacePassword {
+    fn get_password_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn provide_password(&self, password: &str) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_password_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelInterfacePassword,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Password", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let password_flags = d.get_password_flags()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(password_flags);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetPasswordFlags", Default::default(), h);
+    let m = m.out_arg(("Password_Flags", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let password: &str = i.read()?;
+        let d = fclone(minfo);
+        let correct = d.provide_password(password)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(correct);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ProvidePassword", Default::default(), h);
+    let m = m.in_arg(("Password", "s"));
+    let m = m.out_arg(("Correct", "b"));
+    let i = i.add_m(m);
+    let s = factory.signal("PasswordFlagsChanged", Default::default());
+    let s = s.arg(("Added", "u"));
+    let s = s.arg(("Removed", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfacePasswordPasswordFlagsChanged {
+    pub added: u32,
+    pub removed: u32,
+}
+
+impl arg::AppendAll for ChannelInterfacePasswordPasswordFlagsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfacePasswordPasswordFlagsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfacePasswordPasswordFlagsChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfacePasswordPasswordFlagsChanged {
+    const NAME: &'static str = "PasswordFlagsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Password";
+}

src/telepathy/channel_interface_picture.rs

@@ -0,0 +1,195 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Picture.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_picture.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfacePicture1 {
+    fn set_picture(&self, picture: Vec<u8>, mimetype: &str) -> Result<(), tree::MethodErr>;
+    fn picture(&self) -> Result<(Vec<u8>, String), tree::MethodErr>;
+    fn actor(&self) -> Result<String, tree::MethodErr>;
+    fn actor_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn timestamp(&self) -> Result<i64, tree::MethodErr>;
+    fn can_set(&self) -> Result<bool, tree::MethodErr>;
+    fn supported_mimetypes(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn minimum_height(&self) -> Result<u32, tree::MethodErr>;
+    fn minimum_width(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_height(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_height(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_bytes(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_picture1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfacePicture1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Picture1", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let picture: Vec<u8> = i.read()?;
+        let mimetype: &str = i.read()?;
+        let d = fclone(minfo);
+        d.set_picture(picture, mimetype)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetPicture", Default::default(), h);
+    let m = m.in_arg(("Picture", "ay"));
+    let m = m.in_arg(("MIME_Type", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<(Vec<u8>, &str), _>("Picture", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.picture()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Actor", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.actor()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ActorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.actor_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Timestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanSet", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_set()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedMIMETypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_mimetypes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.minimum_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.minimum_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.recommended_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.recommended_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumBytes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_bytes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_room.rs

@@ -0,0 +1,83 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_room.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceRoom2 {
+    fn room_name(&self) -> Result<String, tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+    fn creator(&self) -> Result<String, tree::MethodErr>;
+    fn creator_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn creation_timestamp(&self) -> Result<i64, tree::MethodErr>;
+}
+
+pub fn channel_interface_room2_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceRoom2,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Room2", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("RoomName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.room_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Creator", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.creator()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CreatorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.creator_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("CreationTimestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.creation_timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_room_config.rs

@@ -0,0 +1,212 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room_Config.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_room_config.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceRoomConfig1 {
+    fn update_configuration(
+        &self,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn anonymous(&self) -> Result<bool, tree::MethodErr>;
+    fn invite_only(&self) -> Result<bool, tree::MethodErr>;
+    fn limit(&self) -> Result<u32, tree::MethodErr>;
+    fn moderated(&self) -> Result<bool, tree::MethodErr>;
+    fn title(&self) -> Result<String, tree::MethodErr>;
+    fn description(&self) -> Result<String, tree::MethodErr>;
+    fn persistent(&self) -> Result<bool, tree::MethodErr>;
+    fn private(&self) -> Result<bool, tree::MethodErr>;
+    fn password_protected(&self) -> Result<bool, tree::MethodErr>;
+    fn password(&self) -> Result<String, tree::MethodErr>;
+    fn password_hint(&self) -> Result<String, tree::MethodErr>;
+    fn can_update_configuration(&self) -> Result<bool, tree::MethodErr>;
+    fn mutable_properties(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn configuration_retrieved(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_room_config1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceRoomConfig1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.RoomConfig1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.update_configuration(properties)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateConfiguration", Default::default(), h);
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("Anonymous", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymous()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InviteOnly", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.invite_only()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Limit", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.limit()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Moderated", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.moderated()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Title", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.title()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Description", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.description()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Persistent", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.persistent()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Private", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.private()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("PasswordProtected", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.password_protected()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Password", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.password()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("PasswordHint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.password_hint()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanUpdateConfiguration", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_update_configuration()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("MutableProperties", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.mutable_properties()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ConfigurationRetrieved", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.configuration_retrieved()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_sasl_authentication.rs

@@ -0,0 +1,295 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SASL_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_sasl_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSASLAuthentication {
+    fn start_mechanism(&self, mechanism: &str) -> Result<(), tree::MethodErr>;
+    fn start_mechanism_with_data(
+        &self,
+        mechanism: &str,
+        initial_data: Vec<u8>,
+    ) -> Result<(), tree::MethodErr>;
+    fn respond(&self, response_data: Vec<u8>) -> Result<(), tree::MethodErr>;
+    fn accept_sasl(&self) -> Result<(), tree::MethodErr>;
+    fn abort_sasl(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>;
+    fn available_mechanisms(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn has_initial_data(&self) -> Result<bool, tree::MethodErr>;
+    fn can_try_again(&self) -> Result<bool, tree::MethodErr>;
+    fn saslstatus(&self) -> Result<u32, tree::MethodErr>;
+    fn saslerror(&self) -> Result<String, tree::MethodErr>;
+    fn saslerror_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn authorization_identity(&self) -> Result<String, tree::MethodErr>;
+    fn default_username(&self) -> Result<String, tree::MethodErr>;
+    fn default_realm(&self) -> Result<String, tree::MethodErr>;
+    fn may_save_response(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_saslauthentication_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceSASLAuthentication,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let mechanism: &str = i.read()?;
+        let d = fclone(minfo);
+        d.start_mechanism(mechanism)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartMechanism", Default::default(), h);
+    let m = m.in_arg(("Mechanism", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let mechanism: &str = i.read()?;
+        let initial_data: Vec<u8> = i.read()?;
+        let d = fclone(minfo);
+        d.start_mechanism_with_data(mechanism, initial_data)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartMechanismWithData", Default::default(), h);
+    let m = m.in_arg(("Mechanism", "s"));
+    let m = m.in_arg(("Initial_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let response_data: Vec<u8> = i.read()?;
+        let d = fclone(minfo);
+        d.respond(response_data)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Respond", Default::default(), h);
+    let m = m.in_arg(("Response_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.accept_sasl()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptSASL", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let debug_message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.abort_sasl(reason, debug_message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AbortSASL", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Debug_Message", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("AvailableMechanisms", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.available_mechanisms()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasInitialData", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.has_initial_data()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanTryAgain", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_try_again()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SASLStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.saslstatus()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("SASLError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.saslerror()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "SASLErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.saslerror_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("AuthorizationIdentity", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.authorization_identity()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DefaultUsername", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.default_username()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DefaultRealm", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.default_realm()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("MaySaveResponse", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.may_save_response()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SASLStatusChanged", Default::default());
+    let s = s.arg(("Status", "u"));
+    let s = s.arg(("Reason", "s"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("NewChallenge", Default::default());
+    let s = s.arg(("Challenge_Data", "ay"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    pub status: u32,
+    pub reason: String,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.status, i);
+        arg::RefArg::append(&self.reason, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+            status: i.read()?,
+            reason: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    const NAME: &'static str = "SASLStatusChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSASLAuthenticationNewChallenge {
+    pub challenge_data: Vec<u8>,
+}
+
+impl arg::AppendAll for ChannelInterfaceSASLAuthenticationNewChallenge {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.challenge_data, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSASLAuthenticationNewChallenge {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSASLAuthenticationNewChallenge {
+            challenge_data: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationNewChallenge {
+    const NAME: &'static str = "NewChallenge";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication";
+}

src/telepathy/channel_interface_securable.rs

@@ -0,0 +1,50 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Securable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_securable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSecurable {
+    fn encrypted(&self) -> Result<bool, tree::MethodErr>;
+    fn verified(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_securable_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceSecurable,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Securable",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<bool, _>("Encrypted", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.encrypted()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Verified", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.verified()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_service_point.rs

@@ -0,0 +1,78 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Service_Point.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_service_point.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceServicePoint {
+    fn initial_service_point(&self) -> Result<(u32, String), tree::MethodErr>;
+    fn current_service_point(&self) -> Result<(u32, String), tree::MethodErr>;
+}
+
+pub fn channel_interface_service_point_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceServicePoint,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.ServicePoint",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(u32, &str), _>("InitialServicePoint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_service_point()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str), _>("CurrentServicePoint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.current_service_point()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ServicePointChanged", Default::default());
+    let s = s.arg(("Service_Point", "(us)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceServicePointServicePointChanged {
+    pub service_point: (u32, String),
+}
+
+impl arg::AppendAll for ChannelInterfaceServicePointServicePointChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.service_point, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceServicePointServicePointChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceServicePointServicePointChanged {
+            service_point: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceServicePointServicePointChanged {
+    const NAME: &'static str = "ServicePointChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ServicePoint";
+}

src/telepathy/channel_interface_sms.rs

@@ -0,0 +1,99 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SMS.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_sms.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSMS {
+    fn get_smslength(
+        &self,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+    ) -> Result<(u32, i32, i32), tree::MethodErr>;
+    fn flash(&self) -> Result<bool, tree::MethodErr>;
+    fn smschannel(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_sms_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceSMS,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.SMS", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        let (chunks_required, remaining_characters, estimated_cost) = d.get_smslength(message)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(chunks_required);
+        let rm = rm.append1(remaining_characters);
+        let rm = rm.append1(estimated_cost);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSMSLength", Default::default(), h);
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.out_arg(("Chunks_Required", "u"));
+    let m = m.out_arg(("Remaining_Characters", "i"));
+    let m = m.out_arg(("Estimated_Cost", "i"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("Flash", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.flash()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("SMSChannel", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.smschannel()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SMSChannelChanged", Default::default());
+    let s = s.arg(("SMSChannel", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSMSSMSChannelChanged {
+    pub smschannel: bool,
+}
+
+impl arg::AppendAll for ChannelInterfaceSMSSMSChannelChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.smschannel, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSMSSMSChannelChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSMSSMSChannelChanged {
+            smschannel: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSMSSMSChannelChanged {
+    const NAME: &'static str = "SMSChannelChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.SMS";
+}

src/telepathy/channel_interface_splittable.rs

@@ -0,0 +1,36 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Splittable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_splittable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSplittableDRAFT {
+    fn split(&self) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_splittable_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceSplittableDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Splittable.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.split()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Split", Default::default(), h);
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_subject.rs

@@ -0,0 +1,97 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Subject.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_subject.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSubject2 {
+    fn set_subject(&self, subject: &str) -> Result<(), tree::MethodErr>;
+    fn subject(&self) -> Result<String, tree::MethodErr>;
+    fn actor(&self) -> Result<String, tree::MethodErr>;
+    fn actor_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn timestamp(&self) -> Result<i64, tree::MethodErr>;
+    fn can_set(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_subject2_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelInterfaceSubject2,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Subject2", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let subject: &str = i.read()?;
+        let d = fclone(minfo);
+        d.set_subject(subject)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSubject", Default::default(), h);
+    let m = m.in_arg(("Subject", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("Subject", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.subject()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Actor", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.actor()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ActorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.actor_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Timestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanSet", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.can_set()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_interface_transfer.rs

@@ -0,0 +1,38 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Transfer.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_transfer.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceTransfer {
+    fn transfer(&self, member: u32, destination: u32) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_transfer_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelInterfaceTransfer,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Transfer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let member: u32 = i.read()?;
+        let destination: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.transfer(member, destination)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Transfer", Default::default(), h);
+    let m = m.in_arg(("Member", "u"));
+    let m = m.in_arg(("Destination", "u"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/channel_interface_tube.rs

@@ -0,0 +1,82 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_tube.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceTube {
+    fn parameters(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_tube_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelInterfaceTube,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Tube", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Parameters",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.parameters()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TubeChannelStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceTubeTubeChannelStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceTubeTubeChannelStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceTubeTubeChannelStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceTubeTubeChannelStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceTubeTubeChannelStateChanged {
+    const NAME: &'static str = "TubeChannelStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Tube";
+}

src/telepathy/channel_request.rs

@@ -0,0 +1,228 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Request.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_request.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelRequest {
+    fn proceed(&self) -> Result<(), tree::MethodErr>;
+    fn cancel(&self) -> Result<(), tree::MethodErr>;
+    fn account(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn user_action_time(&self) -> Result<i64, tree::MethodErr>;
+    fn preferred_handler(&self) -> Result<String, tree::MethodErr>;
+    fn requests(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn hints(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_request_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelRequest,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelRequest", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.proceed()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Proceed", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.cancel()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Cancel", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<dbus::Path, _>("Account", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.account()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("UserActionTime", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.user_action_time()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("PreferredHandler", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.preferred_handler()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "Requests",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.requests()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Hints",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.hints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Failed", Default::default());
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("Succeeded", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("SucceededWithChannel", Default::default());
+    let s = s.arg(("Connection", "o"));
+    let s = s.arg(("Connection_Properties", "a{sv}"));
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Channel_Properties", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestFailed {
+    pub error: String,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelRequestFailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelRequestFailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestFailed {
+            error: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestFailed {
+    const NAME: &'static str = "Failed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestSucceeded {}
+
+impl arg::AppendAll for ChannelRequestSucceeded {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelRequestSucceeded {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestSucceeded {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestSucceeded {
+    const NAME: &'static str = "Succeeded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestSucceededWithChannel {
+    pub connection: dbus::Path<'static>,
+    pub connection_properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    pub channel: dbus::Path<'static>,
+    pub channel_properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelRequestSucceededWithChannel {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.connection, i);
+        arg::RefArg::append(&self.connection_properties, i);
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.channel_properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelRequestSucceededWithChannel {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestSucceededWithChannel {
+            connection: i.read()?,
+            connection_properties: i.read()?,
+            channel: i.read()?,
+            channel_properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestSucceededWithChannel {
+    const NAME: &'static str = "SucceededWithChannel";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}

src/telepathy/channel_type_call.rs

@@ -0,0 +1,423 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Call.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_call.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeCall1 {
+    fn set_ringing(&self) -> Result<(), tree::MethodErr>;
+    fn set_queued(&self) -> Result<(), tree::MethodErr>;
+    fn accept(&self) -> Result<(), tree::MethodErr>;
+    fn hangup(
+        &self,
+        reason: u32,
+        detailed_hangup_reason: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn add_content(
+        &self,
+        content_name: &str,
+        content_type: u32,
+        initial_direction: u32,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn contents(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn call_state_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn call_state(&self) -> Result<u32, tree::MethodErr>;
+    fn call_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn call_state_reason(&self) -> Result<(u32, u32, String, String), tree::MethodErr>;
+    fn hardware_streaming(&self) -> Result<bool, tree::MethodErr>;
+    fn call_members(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn initial_transport(&self) -> Result<u32, tree::MethodErr>;
+    fn initial_audio(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_video(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_audio_name(&self) -> Result<String, tree::MethodErr>;
+    fn initial_video_name(&self) -> Result<String, tree::MethodErr>;
+    fn mutable_contents(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_type_call1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeCall1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Call1", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.set_ringing()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetRinging", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.set_queued()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetQueued", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.accept()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let detailed_hangup_reason: &str = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.hangup(reason, detailed_hangup_reason, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Hangup", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Detailed_Hangup_Reason", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let content_name: &str = i.read()?;
+        let content_type: u32 = i.read()?;
+        let initial_direction: u32 = i.read()?;
+        let d = fclone(minfo);
+        let content = d.add_content(content_name, content_type, initial_direction)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(content);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddContent", Default::default(), h);
+    let m = m.in_arg(("Content_Name", "s"));
+    let m = m.in_arg(("Content_Type", "u"));
+    let m = m.in_arg(("InitialDirection", "u"));
+    let m = m.out_arg(("Content", "o"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Contents", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.contents()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "CallStateDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.call_state_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CallState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.call_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CallFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.call_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, u32, &str, &str), _>("CallStateReason", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.call_state_reason()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HardwareStreaming", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.hardware_streaming()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("CallMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.call_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "MemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("InitialTransport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InitialAudio", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_audio()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InitialVideo", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_video()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialAudioName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_audio_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialVideoName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_video_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("MutableContents", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.mutable_contents()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ContentAdded", Default::default());
+    let s = s.arg(("Content", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("ContentRemoved", Default::default());
+    let s = s.arg(("Content", "o"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    let s = factory.signal("CallStateChanged", Default::default());
+    let s = s.arg(("Call_State", "u"));
+    let s = s.arg(("Call_Flags", "u"));
+    let s = s.arg(("Call_State_Reason", "(uuss)"));
+    let s = s.arg(("Call_State_Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("CallMembersChanged", Default::default());
+    let s = s.arg(("Flags_Changed", "a{uu}"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1ContentAdded {
+    pub content: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for ChannelTypeCall1ContentAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1ContentAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1ContentAdded { content: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1ContentAdded {
+    const NAME: &'static str = "ContentAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1ContentRemoved {
+    pub content: dbus::Path<'static>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for ChannelTypeCall1ContentRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1ContentRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1ContentRemoved {
+            content: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1ContentRemoved {
+    const NAME: &'static str = "ContentRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1CallStateChanged {
+    pub call_state: u32,
+    pub call_flags: u32,
+    pub call_state_reason: (u32, u32, String, String),
+    pub call_state_details:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelTypeCall1CallStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.call_state, i);
+        arg::RefArg::append(&self.call_flags, i);
+        arg::RefArg::append(&self.call_state_reason, i);
+        arg::RefArg::append(&self.call_state_details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1CallStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1CallStateChanged {
+            call_state: i.read()?,
+            call_flags: i.read()?,
+            call_state_reason: i.read()?,
+            call_state_details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1CallStateChanged {
+    const NAME: &'static str = "CallStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1CallMembersChanged {
+    pub flags_changed: ::std::collections::HashMap<u32, u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for ChannelTypeCall1CallMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.flags_changed, i);
+        arg::RefArg::append(&self.identifiers, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1CallMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1CallMembersChanged {
+            flags_changed: i.read()?,
+            identifiers: i.read()?,
+            removed: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1CallMembersChanged {
+    const NAME: &'static str = "CallMembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}

src/telepathy/channel_type_contact_list.rs

@@ -0,0 +1,22 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_contact_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeContactList {}
+
+pub fn channel_type_contact_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ChannelTypeContactList,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactList", data);
+    let f = ::std::sync::Arc::new(f);
+    i
+}

src/telepathy/channel_type_contact_search.rs

@@ -0,0 +1,169 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_Search.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_contact_search.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeContactSearch {
+    fn search(&self, terms: ::std::collections::HashMap<&str, &str>)
+        -> Result<(), tree::MethodErr>;
+    fn more(&self) -> Result<(), tree::MethodErr>;
+    fn stop(&self) -> Result<(), tree::MethodErr>;
+    fn search_state(&self) -> Result<u32, tree::MethodErr>;
+    fn limit(&self) -> Result<u32, tree::MethodErr>;
+    fn available_search_keys(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_contact_search_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeContactSearch,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactSearch", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let terms: ::std::collections::HashMap<&str, &str> = i.read()?;
+        let d = fclone(minfo);
+        d.search(terms)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Search", Default::default(), h);
+    let m = m.in_arg(("Terms", "a{ss}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.more()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("More", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.stop()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Stop", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("SearchState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.search_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Limit", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.limit()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("AvailableSearchKeys", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.available_search_keys()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SearchStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("SearchResultReceived", Default::default());
+    let s = s.arg(("Result", "a{sa(sasas)}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeContactSearchSearchStateChanged {
+    pub state: u32,
+    pub error: String,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelTypeContactSearchSearchStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeContactSearchSearchStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeContactSearchSearchStateChanged {
+            state: i.read()?,
+            error: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchStateChanged {
+    const NAME: &'static str = "SearchStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeContactSearchSearchResultReceived {
+    pub result: ::std::collections::HashMap<String, Vec<(String, Vec<String>, Vec<String>)>>,
+}
+
+impl arg::AppendAll for ChannelTypeContactSearchSearchResultReceived {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.result, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeContactSearchSearchResultReceived {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeContactSearchSearchResultReceived { result: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchResultReceived {
+    const NAME: &'static str = "SearchResultReceived";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
+}

src/telepathy/channel_type_dbus_tube.rs

@@ -0,0 +1,131 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_DBus_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_dbus_tube.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeDBusTube {
+    fn offer(
+        &self,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        access_control: u32,
+    ) -> Result<String, tree::MethodErr>;
+    fn accept(&self, access_control: u32) -> Result<String, tree::MethodErr>;
+    fn service_name(&self) -> Result<String, tree::MethodErr>;
+    fn dbus_names(&self) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn supported_access_controls(&self) -> Result<Vec<u32>, tree::MethodErr>;
+}
+
+pub fn channel_type_dbus_tube_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeDBusTube,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.DBusTube", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let access_control: u32 = i.read()?;
+        let d = fclone(minfo);
+        let address = d.offer(parameters, access_control)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("Offer", Default::default(), h);
+    let m = m.in_arg(("parameters", "a{sv}"));
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.out_arg(("address", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let access_control: u32 = i.read()?;
+        let d = fclone(minfo);
+        let address = d.accept(access_control)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.out_arg(("address", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("ServiceName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.service_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, &str>, _>("DBusNames", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.dbus_names()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("SupportedAccessControls", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_access_controls()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("DBusNamesChanged", Default::default());
+    let s = s.arg(("Added", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeDBusTubeDBusNamesChanged {
+    pub added: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelTypeDBusTubeDBusNamesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeDBusTubeDBusNamesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeDBusTubeDBusNamesChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeDBusTubeDBusNamesChanged {
+    const NAME: &'static str = "DBusNamesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.DBusTube";
+}

src/telepathy/channel_type_file_transfer.rs

@@ -0,0 +1,354 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_File_Transfer.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_file_transfer.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeFileTransfer {
+    fn accept_file(
+        &self,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+        offset: u64,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn provide_file(
+        &self,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+    fn content_type(&self) -> Result<String, tree::MethodErr>;
+    fn filename(&self) -> Result<String, tree::MethodErr>;
+    fn size(&self) -> Result<u64, tree::MethodErr>;
+    fn content_hash_type(&self) -> Result<u32, tree::MethodErr>;
+    fn content_hash(&self) -> Result<String, tree::MethodErr>;
+    fn description(&self) -> Result<String, tree::MethodErr>;
+    fn date(&self) -> Result<i64, tree::MethodErr>;
+    fn available_socket_types(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+    fn transferred_bytes(&self) -> Result<u64, tree::MethodErr>;
+    fn initial_offset(&self) -> Result<u64, tree::MethodErr>;
+    fn uri(&self) -> Result<String, tree::MethodErr>;
+    fn set_uri(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn file_collection(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_file_transfer_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeFileTransfer,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.FileTransfer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let offset: u64 = i.read()?;
+        let d = fclone(minfo);
+        let address = d.accept_file(address_type, access_control, access_control_param, offset)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptFile", Default::default(), h);
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.in_arg(("Offset", "t"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let d = fclone(minfo);
+        let address = d.provide_file(address_type, access_control, access_control_param)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ProvideFile", Default::default(), h);
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ContentType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.content_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Filename", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.filename()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("Size", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ContentHashType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.content_hash_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ContentHash", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.content_hash()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Description", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.description()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Date", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.date()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, Vec<u32>>, _>(
+        "AvailableSocketTypes",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.available_socket_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("TransferredBytes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.transferred_bytes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("InitialOffset", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_offset()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("URI", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.uri()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_uri(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("FileCollection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.file_collection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("FileTransferStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("TransferredBytesChanged", Default::default());
+    let s = s.arg(("Count", "t"));
+    let i = i.add_s(s);
+    let s = factory.signal("InitialOffsetDefined", Default::default());
+    let s = s.arg(("InitialOffset", "t"));
+    let i = i.add_s(s);
+    let s = factory.signal("URIDefined", Default::default());
+    let s = s.arg(("URI", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferFileTransferStateChanged {
+    pub state: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferFileTransferStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferFileTransferStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferFileTransferStateChanged {
+            state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferFileTransferStateChanged {
+    const NAME: &'static str = "FileTransferStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferTransferredBytesChanged {
+    pub count: u64,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferTransferredBytesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.count, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferTransferredBytesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferTransferredBytesChanged { count: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferTransferredBytesChanged {
+    const NAME: &'static str = "TransferredBytesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferInitialOffsetDefined {
+    pub initial_offset: u64,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferInitialOffsetDefined {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.initial_offset, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferInitialOffsetDefined {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferInitialOffsetDefined {
+            initial_offset: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferInitialOffsetDefined {
+    const NAME: &'static str = "InitialOffsetDefined";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferURIDefined {
+    pub uri: String,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferURIDefined {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.uri, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferURIDefined {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferURIDefined { uri: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferURIDefined {
+    const NAME: &'static str = "URIDefined";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}

src/telepathy/channel_type_room_list.rs

@@ -0,0 +1,125 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Room_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_room_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeRoomList {
+    fn get_listing_rooms(&self) -> Result<bool, tree::MethodErr>;
+    fn list_rooms(&self) -> Result<(), tree::MethodErr>;
+    fn stop_listing(&self) -> Result<(), tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_room_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeRoomList,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.RoomList", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let in_progress = d.get_listing_rooms()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(in_progress);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetListingRooms", Default::default(), h);
+    let m = m.out_arg(("In_Progress", "b"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.list_rooms()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListRooms", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.stop_listing()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopListing", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("GotRooms", Default::default());
+    let s = s.arg(("Rooms", "a(usa{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("ListingRooms", Default::default());
+    let s = s.arg(("Listing", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeRoomListGotRooms {
+    pub rooms: Vec<(
+        u32,
+        String,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for ChannelTypeRoomListGotRooms {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.rooms, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeRoomListGotRooms {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeRoomListGotRooms { rooms: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeRoomListGotRooms {
+    const NAME: &'static str = "GotRooms";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeRoomListListingRooms {
+    pub listing: bool,
+}
+
+impl arg::AppendAll for ChannelTypeRoomListListingRooms {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.listing, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeRoomListListingRooms {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeRoomListListingRooms { listing: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeRoomListListingRooms {
+    const NAME: &'static str = "ListingRooms";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList";
+}

src/telepathy/channel_type_server_authentication.rs

@@ -0,0 +1,38 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Server_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_server_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeServerAuthentication {
+    fn authentication_method(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_server_authentication_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelTypeServerAuthentication,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Type.ServerAuthentication",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("AuthenticationMethod", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.authentication_method()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_type_server_tls_connection.rs

@@ -0,0 +1,62 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Server_TLS_Connection.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_server_tls_connection.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeServerTLSConnection {
+    fn server_certificate(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn hostname(&self) -> Result<String, tree::MethodErr>;
+    fn reference_identities(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn channel_type_server_tlsconnection_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ChannelTypeServerTLSConnection,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<dbus::Path, _>("ServerCertificate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.server_certificate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Hostname", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.hostname()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("ReferenceIdentities", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.reference_identities()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/channel_type_stream_tube.rs

@@ -0,0 +1,202 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Stream_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_stream_tube.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeStreamTube {
+    fn offer(
+        &self,
+        address_type: u32,
+        address: arg::Variant<Box<dyn arg::RefArg>>,
+        access_control: u32,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn accept(
+        &self,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn service(&self) -> Result<String, tree::MethodErr>;
+    fn supported_socket_types(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+}
+
+pub fn channel_type_stream_tube_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeStreamTube,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.StreamTube", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let address: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let access_control: u32 = i.read()?;
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.offer(address_type, address, access_control, parameters)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Offer", Default::default(), h);
+    let m = m.in_arg(("address_type", "u"));
+    let m = m.in_arg(("address", "v"));
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.in_arg(("parameters", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let d = fclone(minfo);
+        let address = d.accept(address_type, access_control, access_control_param)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let m = m.in_arg(("address_type", "u"));
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.in_arg(("access_control_param", "v"));
+    let m = m.out_arg(("address", "v"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("Service", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.service()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, Vec<u32>>, _>(
+        "SupportedSocketTypes",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_socket_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("NewRemoteConnection", Default::default());
+    let s = s.arg(("Handle", "u"));
+    let s = s.arg(("Connection_Param", "v"));
+    let s = s.arg(("Connection_ID", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("NewLocalConnection", Default::default());
+    let s = s.arg(("Connection_ID", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("ConnectionClosed", Default::default());
+    let s = s.arg(("Connection_ID", "u"));
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamTubeNewRemoteConnection {
+    pub handle: u32,
+    pub connection_param: arg::Variant<Box<dyn arg::RefArg + 'static>>,
+    pub connection_id: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamTubeNewRemoteConnection {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.handle, i);
+        arg::RefArg::append(&self.connection_param, i);
+        arg::RefArg::append(&self.connection_id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamTubeNewRemoteConnection {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamTubeNewRemoteConnection {
+            handle: i.read()?,
+            connection_param: i.read()?,
+            connection_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamTubeNewRemoteConnection {
+    const NAME: &'static str = "NewRemoteConnection";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamTubeNewLocalConnection {
+    pub connection_id: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamTubeNewLocalConnection {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.connection_id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamTubeNewLocalConnection {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamTubeNewLocalConnection {
+            connection_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamTubeNewLocalConnection {
+    const NAME: &'static str = "NewLocalConnection";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamTubeConnectionClosed {
+    pub connection_id: u32,
+    pub error: String,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelTypeStreamTubeConnectionClosed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.connection_id, i);
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamTubeConnectionClosed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamTubeConnectionClosed {
+            connection_id: i.read()?,
+            error: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamTubeConnectionClosed {
+    const NAME: &'static str = "ConnectionClosed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube";
+}

src/telepathy/channel_type_streamed_media.rs

@@ -0,0 +1,292 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Streamed_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_streamed_media.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeStreamedMedia {
+    fn list_streams(&self) -> Result<Vec<(u32, u32, u32, u32, u32, u32)>, tree::MethodErr>;
+    fn remove_streams(&self, streams: Vec<u32>) -> Result<(), tree::MethodErr>;
+    fn request_stream_direction(
+        &self,
+        stream_id: u32,
+        stream_direction: u32,
+    ) -> Result<(), tree::MethodErr>;
+    fn request_streams(
+        &self,
+        contact_handle: u32,
+        types: Vec<u32>,
+    ) -> Result<Vec<(u32, u32, u32, u32, u32, u32)>, tree::MethodErr>;
+    fn initial_audio(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_video(&self) -> Result<bool, tree::MethodErr>;
+    fn immutable_streams(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_type_streamed_media_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ChannelTypeStreamedMedia,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.StreamedMedia", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let streams = d.list_streams()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(streams);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListStreams", Default::default(), h);
+    let m = m.out_arg(("Streams", "a(uuuuuu)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let streams: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        d.remove_streams(streams)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveStreams", Default::default(), h);
+    let m = m.in_arg(("Streams", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let stream_id: u32 = i.read()?;
+        let stream_direction: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.request_stream_direction(stream_id, stream_direction)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestStreamDirection", Default::default(), h);
+    let m = m.in_arg(("Stream_ID", "u"));
+    let m = m.in_arg(("Stream_Direction", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contact_handle: u32 = i.read()?;
+        let types: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let streams = d.request_streams(contact_handle, types)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(streams);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestStreams", Default::default(), h);
+    let m = m.in_arg(("Contact_Handle", "u"));
+    let m = m.in_arg(("Types", "au"));
+    let m = m.out_arg(("Streams", "a(uuuuuu)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("InitialAudio", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_audio()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InitialVideo", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.initial_video()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ImmutableStreams", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.immutable_streams()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("StreamAdded", Default::default());
+    let s = s.arg(("Stream_ID", "u"));
+    let s = s.arg(("Contact_Handle", "u"));
+    let s = s.arg(("Stream_Type", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamDirectionChanged", Default::default());
+    let s = s.arg(("Stream_ID", "u"));
+    let s = s.arg(("Stream_Direction", "u"));
+    let s = s.arg(("Pending_Flags", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamError", Default::default());
+    let s = s.arg(("Stream_ID", "u"));
+    let s = s.arg(("Error_Code", "u"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamRemoved", Default::default());
+    let s = s.arg(("Stream_ID", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamStateChanged", Default::default());
+    let s = s.arg(("Stream_ID", "u"));
+    let s = s.arg(("Stream_State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamedMediaStreamAdded {
+    pub stream_id: u32,
+    pub contact_handle: u32,
+    pub stream_type: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamedMediaStreamAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.stream_id, i);
+        arg::RefArg::append(&self.contact_handle, i);
+        arg::RefArg::append(&self.stream_type, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamedMediaStreamAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamedMediaStreamAdded {
+            stream_id: i.read()?,
+            contact_handle: i.read()?,
+            stream_type: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamAdded {
+    const NAME: &'static str = "StreamAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamedMediaStreamDirectionChanged {
+    pub stream_id: u32,
+    pub stream_direction: u32,
+    pub pending_flags: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamedMediaStreamDirectionChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.stream_id, i);
+        arg::RefArg::append(&self.stream_direction, i);
+        arg::RefArg::append(&self.pending_flags, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamedMediaStreamDirectionChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamedMediaStreamDirectionChanged {
+            stream_id: i.read()?,
+            stream_direction: i.read()?,
+            pending_flags: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamDirectionChanged {
+    const NAME: &'static str = "StreamDirectionChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamedMediaStreamError {
+    pub stream_id: u32,
+    pub error_code: u32,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelTypeStreamedMediaStreamError {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.stream_id, i);
+        arg::RefArg::append(&self.error_code, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamedMediaStreamError {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamedMediaStreamError {
+            stream_id: i.read()?,
+            error_code: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamError {
+    const NAME: &'static str = "StreamError";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamedMediaStreamRemoved {
+    pub stream_id: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamedMediaStreamRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.stream_id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamedMediaStreamRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamedMediaStreamRemoved {
+            stream_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamRemoved {
+    const NAME: &'static str = "StreamRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeStreamedMediaStreamStateChanged {
+    pub stream_id: u32,
+    pub stream_state: u32,
+}
+
+impl arg::AppendAll for ChannelTypeStreamedMediaStreamStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.stream_id, i);
+        arg::RefArg::append(&self.stream_state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeStreamedMediaStreamStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeStreamedMediaStreamStateChanged {
+            stream_id: i.read()?,
+            stream_state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamStateChanged {
+    const NAME: &'static str = "StreamStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
+}

src/telepathy/channel_type_text.rs

@@ -0,0 +1,226 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Text.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_text.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeText {
+    fn acknowledge_pending_messages(&self, ids: Vec<u32>) -> Result<(), tree::MethodErr>;
+    fn get_message_types(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn list_pending_messages(
+        &self,
+        clear: bool,
+    ) -> Result<Vec<(u32, u32, u32, u32, u32, String)>, tree::MethodErr>;
+    fn send(&self, type_: u32, text: &str) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_type_text_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelTypeText,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Text", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let ids: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        d.acknowledge_pending_messages(ids)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcknowledgePendingMessages", Default::default(), h);
+    let m = m.in_arg(("IDs", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let available_types = d.get_message_types()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(available_types);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetMessageTypes", Default::default(), h);
+    let m = m.out_arg(("Available_Types", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let clear: bool = i.read()?;
+        let d = fclone(minfo);
+        let pending_messages = d.list_pending_messages(clear)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(pending_messages);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListPendingMessages", Default::default(), h);
+    let m = m.in_arg(("Clear", "b"));
+    let m = m.out_arg(("Pending_Messages", "a(uuuuus)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let type_: u32 = i.read()?;
+        let text: &str = i.read()?;
+        let d = fclone(minfo);
+        d.send(type_, text)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Send", Default::default(), h);
+    let m = m.in_arg(("Type", "u"));
+    let m = m.in_arg(("Text", "s"));
+    let i = i.add_m(m);
+    let s = factory.signal("LostMessage", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("Received", Default::default());
+    let s = s.arg(("ID", "u"));
+    let s = s.arg(("Timestamp", "u"));
+    let s = s.arg(("Sender", "u"));
+    let s = s.arg(("Type", "u"));
+    let s = s.arg(("Flags", "u"));
+    let s = s.arg(("Text", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("SendError", Default::default());
+    let s = s.arg(("Error", "u"));
+    let s = s.arg(("Timestamp", "u"));
+    let s = s.arg(("Type", "u"));
+    let s = s.arg(("Text", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("Sent", Default::default());
+    let s = s.arg(("Timestamp", "u"));
+    let s = s.arg(("Type", "u"));
+    let s = s.arg(("Text", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTextLostMessage {}
+
+impl arg::AppendAll for ChannelTypeTextLostMessage {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelTypeTextLostMessage {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTextLostMessage {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTextLostMessage {
+    const NAME: &'static str = "LostMessage";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTextReceived {
+    pub id: u32,
+    pub timestamp: u32,
+    pub sender: u32,
+    pub type_: u32,
+    pub flags: u32,
+    pub text: String,
+}
+
+impl arg::AppendAll for ChannelTypeTextReceived {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.timestamp, i);
+        arg::RefArg::append(&self.sender, i);
+        arg::RefArg::append(&self.type_, i);
+        arg::RefArg::append(&self.flags, i);
+        arg::RefArg::append(&self.text, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTextReceived {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTextReceived {
+            id: i.read()?,
+            timestamp: i.read()?,
+            sender: i.read()?,
+            type_: i.read()?,
+            flags: i.read()?,
+            text: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTextReceived {
+    const NAME: &'static str = "Received";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTextSendError {
+    pub error: u32,
+    pub timestamp: u32,
+    pub type_: u32,
+    pub text: String,
+}
+
+impl arg::AppendAll for ChannelTypeTextSendError {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.timestamp, i);
+        arg::RefArg::append(&self.type_, i);
+        arg::RefArg::append(&self.text, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTextSendError {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTextSendError {
+            error: i.read()?,
+            timestamp: i.read()?,
+            type_: i.read()?,
+            text: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTextSendError {
+    const NAME: &'static str = "SendError";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTextSent {
+    pub timestamp: u32,
+    pub type_: u32,
+    pub text: String,
+}
+
+impl arg::AppendAll for ChannelTypeTextSent {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.timestamp, i);
+        arg::RefArg::append(&self.type_, i);
+        arg::RefArg::append(&self.text, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTextSent {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTextSent {
+            timestamp: i.read()?,
+            type_: i.read()?,
+            text: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTextSent {
+    const NAME: &'static str = "Sent";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text";
+}

src/telepathy/channel_type_tubes.rs

@@ -0,0 +1,423 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Tubes.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_tubes.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeTubes {
+    fn get_available_stream_tube_types(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+    fn get_available_tube_types(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn list_tubes(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            u32,
+            u32,
+            String,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            u32,
+        )>,
+        tree::MethodErr,
+    >;
+    fn offer_dbus_tube(
+        &self,
+        service: &str,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<u32, tree::MethodErr>;
+    fn offer_stream_tube(
+        &self,
+        service: &str,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        address_type: u32,
+        address: arg::Variant<Box<dyn arg::RefArg>>,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+    ) -> Result<u32, tree::MethodErr>;
+    fn accept_dbus_tube(&self, id: u32) -> Result<String, tree::MethodErr>;
+    fn accept_stream_tube(
+        &self,
+        id: u32,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn close_tube(&self, id: u32) -> Result<(), tree::MethodErr>;
+    fn get_dbus_tube_address(&self, id: u32) -> Result<String, tree::MethodErr>;
+    fn get_dbus_names(&self, id: u32) -> Result<Vec<(u32, String)>, tree::MethodErr>;
+    fn get_stream_tube_socket_address(
+        &self,
+        id: u32,
+    ) -> Result<(u32, arg::Variant<Box<dyn arg::RefArg + 'static>>), tree::MethodErr>;
+}
+
+pub fn channel_type_tubes_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ChannelTypeTubes,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Tubes", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let available_stream_tube_types = d.get_available_stream_tube_types()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(available_stream_tube_types);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAvailableStreamTubeTypes", Default::default(), h);
+    let m = m.out_arg(("Available_Stream_Tube_Types", "a{uau}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let available_tube_types = d.get_available_tube_types()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(available_tube_types);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAvailableTubeTypes", Default::default(), h);
+    let m = m.out_arg(("Available_Tube_Types", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let tubes = d.list_tubes()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(tubes);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListTubes", Default::default(), h);
+    let m = m.out_arg(("Tubes", "a(uuusa{sv}u)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let service: &str = i.read()?;
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        let tube_id = d.offer_dbus_tube(service, parameters)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(tube_id);
+        Ok(vec![rm])
+    };
+    let m = factory.method("OfferDBusTube", Default::default(), h);
+    let m = m.in_arg(("Service", "s"));
+    let m = m.in_arg(("Parameters", "a{sv}"));
+    let m = m.out_arg(("Tube_ID", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let service: &str = i.read()?;
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let address_type: u32 = i.read()?;
+        let address: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let d = fclone(minfo);
+        let tube_id = d.offer_stream_tube(
+            service,
+            parameters,
+            address_type,
+            address,
+            access_control,
+            access_control_param,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(tube_id);
+        Ok(vec![rm])
+    };
+    let m = factory.method("OfferStreamTube", Default::default(), h);
+    let m = m.in_arg(("Service", "s"));
+    let m = m.in_arg(("Parameters", "a{sv}"));
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Address", "v"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.out_arg(("Tube_ID", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let d = fclone(minfo);
+        let address = d.accept_dbus_tube(id)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptDBusTube", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.out_arg(("Address", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let d = fclone(minfo);
+        let address =
+            d.accept_stream_tube(id, address_type, access_control, access_control_param)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptStreamTube", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let d = fclone(minfo);
+        d.close_tube(id)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CloseTube", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let d = fclone(minfo);
+        let address = d.get_dbus_tube_address(id)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetDBusTubeAddress", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.out_arg(("Address", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let d = fclone(minfo);
+        let dbus_names = d.get_dbus_names(id)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(dbus_names);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetDBusNames", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.out_arg(("DBus_Names", "a(us)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let d = fclone(minfo);
+        let (address_type, address) = d.get_stream_tube_socket_address(id)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address_type);
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetStreamTubeSocketAddress", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.out_arg(("Address_Type", "u"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+    let s = factory.signal("NewTube", Default::default());
+    let s = s.arg(("ID", "u"));
+    let s = s.arg(("Initiator", "u"));
+    let s = s.arg(("Type", "u"));
+    let s = s.arg(("Service", "s"));
+    let s = s.arg(("Parameters", "a{sv}"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("TubeStateChanged", Default::default());
+    let s = s.arg(("ID", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("TubeClosed", Default::default());
+    let s = s.arg(("ID", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("DBusNamesChanged", Default::default());
+    let s = s.arg(("ID", "u"));
+    let s = s.arg(("Added", "a(us)"));
+    let s = s.arg(("Removed", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamTubeNewConnection", Default::default());
+    let s = s.arg(("ID", "u"));
+    let s = s.arg(("Handle", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTubesNewTube {
+    pub id: u32,
+    pub initiator: u32,
+    pub type_: u32,
+    pub service: String,
+    pub parameters:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelTypeTubesNewTube {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.initiator, i);
+        arg::RefArg::append(&self.type_, i);
+        arg::RefArg::append(&self.service, i);
+        arg::RefArg::append(&self.parameters, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTubesNewTube {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTubesNewTube {
+            id: i.read()?,
+            initiator: i.read()?,
+            type_: i.read()?,
+            service: i.read()?,
+            parameters: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTubesNewTube {
+    const NAME: &'static str = "NewTube";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTubesTubeStateChanged {
+    pub id: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelTypeTubesTubeStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTubesTubeStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTubesTubeStateChanged {
+            id: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTubesTubeStateChanged {
+    const NAME: &'static str = "TubeStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTubesTubeClosed {
+    pub id: u32,
+}
+
+impl arg::AppendAll for ChannelTypeTubesTubeClosed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTubesTubeClosed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTubesTubeClosed { id: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTubesTubeClosed {
+    const NAME: &'static str = "TubeClosed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTubesDBusNamesChanged {
+    pub id: u32,
+    pub added: Vec<(u32, String)>,
+    pub removed: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelTypeTubesDBusNamesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTubesDBusNamesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTubesDBusNamesChanged {
+            id: i.read()?,
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTubesDBusNamesChanged {
+    const NAME: &'static str = "DBusNamesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeTubesStreamTubeNewConnection {
+    pub id: u32,
+    pub handle: u32,
+}
+
+impl arg::AppendAll for ChannelTypeTubesStreamTubeNewConnection {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.handle, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeTubesStreamTubeNewConnection {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeTubesStreamTubeNewConnection {
+            id: i.read()?,
+            handle: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeTubesStreamTubeNewConnection {
+    const NAME: &'static str = "StreamTubeNewConnection";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes";
+}

src/telepathy/client.rs

@@ -0,0 +1,35 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client.xml -i org.freedesktop.Telepathy -o src/telepathy/client.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Client {
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn client_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: Client,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/client_approver.rs

@@ -0,0 +1,74 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Approver.xml -i org.freedesktop.Telepathy -o src/telepathy/client_approver.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ClientApprover {
+    fn add_dispatch_operation(
+        &self,
+        channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+        dispatch_operation: dbus::Path,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn approver_channel_filter(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn client_approver_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ClientApprover,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client.Approver", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let dispatch_operation: dbus::Path = i.read()?;
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.add_dispatch_operation(channels, dispatch_operation, properties)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddDispatchOperation", Default::default(), h);
+    let m = m.in_arg(("Channels", "a(oa{sv})"));
+    let m = m.in_arg(("DispatchOperation", "o"));
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let i = i.add_m(m);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "ApproverChannelFilter",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.approver_channel_filter()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/client_handler.rs

@@ -0,0 +1,126 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/client_handler.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ClientHandler {
+    fn handle_channels(
+        &self,
+        account: dbus::Path,
+        connection: dbus::Path,
+        channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+        requests_satisfied: Vec<dbus::Path>,
+        user_action_time: u64,
+        handler_info: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn handler_channel_filter(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn bypass_approval(&self) -> Result<bool, tree::MethodErr>;
+    fn capabilities(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn handled_channels(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn client_handler_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ClientHandler,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client.Handler", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let connection: dbus::Path = i.read()?;
+        let channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let requests_satisfied: Vec<dbus::Path> = i.read()?;
+        let user_action_time: u64 = i.read()?;
+        let handler_info: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.handle_channels(
+            account,
+            connection,
+            channels,
+            requests_satisfied,
+            user_action_time,
+            handler_info,
+        )?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleChannels", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Connection", "o"));
+    let m = m.in_arg(("Channels", "a(oa{sv})"));
+    let m = m.in_arg(("Requests_Satisfied", "ao"));
+    let m = m.in_arg(("User_Action_Time", "t"));
+    let m = m.in_arg(("Handler_Info", "a{sv}"));
+    let i = i.add_m(m);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "HandlerChannelFilter",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.handler_channel_filter()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("BypassApproval", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.bypass_approval()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Capabilities", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.capabilities()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("HandledChannels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.handled_channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/client_handler_future.rs

@@ -0,0 +1,47 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Handler_Future.xml -i org.freedesktop.Telepathy -o src/telepathy/client_handler_future.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ClientHandlerFUTURE {
+    fn bypass_observers(&self) -> Result<bool, tree::MethodErr>;
+    fn related_conferences_bypass_approval(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn client_handler_future_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ClientHandlerFUTURE,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client.Handler.FUTURE", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<bool, _>("BypassObservers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.bypass_observers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("RelatedConferencesBypassApproval", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.related_conferences_bypass_approval()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/client_interface_requests.rs

@@ -0,0 +1,66 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Interface_Requests.xml -i org.freedesktop.Telepathy -o src/telepathy/client_interface_requests.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ClientInterfaceRequests {
+    fn add_request(
+        &self,
+        request: dbus::Path,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn remove_request(
+        &self,
+        request: dbus::Path,
+        error: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn client_interface_requests_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ClientInterfaceRequests,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client.Interface.Requests", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let request: dbus::Path = i.read()?;
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.add_request(request, properties)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddRequest", Default::default(), h);
+    let m = m.in_arg(("Request", "o"));
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let request: dbus::Path = i.read()?;
+        let error: &str = i.read()?;
+        let message: &str = i.read()?;
+        let d = fclone(minfo);
+        d.remove_request(request, error, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveRequest", Default::default(), h);
+    let m = m.in_arg(("Request", "o"));
+    let m = m.in_arg(("Error", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/client_observer.rs

@@ -0,0 +1,114 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Observer.xml -i org.freedesktop.Telepathy -o src/telepathy/client_observer.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ClientObserver {
+    fn observe_channels(
+        &self,
+        account: dbus::Path,
+        connection: dbus::Path,
+        channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+        dispatch_operation: dbus::Path,
+        requests_satisfied: Vec<dbus::Path>,
+        observer_info: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn observer_channel_filter(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn recover(&self) -> Result<bool, tree::MethodErr>;
+    fn delay_approvers(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn client_observer_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: ClientObserver,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Client.Observer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let connection: dbus::Path = i.read()?;
+        let channels: Vec<(
+            dbus::Path,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let dispatch_operation: dbus::Path = i.read()?;
+        let requests_satisfied: Vec<dbus::Path> = i.read()?;
+        let observer_info: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let d = fclone(minfo);
+        d.observe_channels(
+            account,
+            connection,
+            channels,
+            dispatch_operation,
+            requests_satisfied,
+            observer_info,
+        )?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ObserveChannels", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Connection", "o"));
+    let m = m.in_arg(("Channels", "a(oa{sv})"));
+    let m = m.in_arg(("Dispatch_Operation", "o"));
+    let m = m.in_arg(("Requests_Satisfied", "ao"));
+    let m = m.in_arg(("Observer_Info", "a{sv}"));
+    let i = i.add_m(m);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "ObserverChannelFilter",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.observer_channel_filter()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Recover", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.recover()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("DelayApprovers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.delay_approvers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}

src/telepathy/connection.rs

@@ -0,0 +1,468 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection.xml -i org.freedesktop.Telepathy -o src/telepathy/connection.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Connection {
+    fn connect(&self) -> Result<(), tree::MethodErr>;
+    fn disconnect(&self) -> Result<(), tree::MethodErr>;
+    fn get_interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn get_protocol(&self) -> Result<String, tree::MethodErr>;
+    fn get_self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn get_status(&self) -> Result<u32, tree::MethodErr>;
+    fn hold_handles(&self, handle_type: u32, handles: Vec<u32>) -> Result<(), tree::MethodErr>;
+    fn inspect_handles(
+        &self,
+        handle_type: u32,
+        handles: Vec<u32>,
+    ) -> Result<Vec<String>, tree::MethodErr>;
+    fn list_channels(
+        &self,
+    ) -> Result<Vec<(dbus::Path<'static>, String, u32, u32)>, tree::MethodErr>;
+    fn release_handles(&self, handle_type: u32, handles: Vec<u32>) -> Result<(), tree::MethodErr>;
+    fn request_channel(
+        &self,
+        type_: &str,
+        handle_type: u32,
+        handle: u32,
+        suppress_handler: bool,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn request_handles(
+        &self,
+        handle_type: u32,
+        identifiers: Vec<&str>,
+    ) -> Result<Vec<u32>, tree::MethodErr>;
+    fn add_client_interest(&self, tokens: Vec<&str>) -> Result<(), tree::MethodErr>;
+    fn remove_client_interest(&self, tokens: Vec<&str>) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn self_id(&self) -> Result<String, tree::MethodErr>;
+    fn status(&self) -> Result<u32, tree::MethodErr>;
+    fn has_immortal_handles(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn connection_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: Connection,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Connection", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.connect()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Connect", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.disconnect()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Disconnect", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let interfaces = d.get_interfaces()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(interfaces);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetInterfaces", Default::default(), h);
+    let m = m.out_arg(("Interfaces", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let protocol = d.get_protocol()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(protocol);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetProtocol", Default::default(), h);
+    let m = m.out_arg(("Protocol", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let self_handle = d.get_self_handle()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(self_handle);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSelfHandle", Default::default(), h);
+    let m = m.out_arg(("Self_Handle", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let status = d.get_status()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(status);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetStatus", Default::default(), h);
+    let m = m.out_arg(("Status", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handle_type: u32 = i.read()?;
+        let handles: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        d.hold_handles(handle_type, handles)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HoldHandles", Default::default(), h);
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handle_type: u32 = i.read()?;
+        let handles: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let identifiers = d.inspect_handles(handle_type, handles)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(identifiers);
+        Ok(vec![rm])
+    };
+    let m = factory.method("InspectHandles", Default::default(), h);
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handles", "au"));
+    let m = m.out_arg(("Identifiers", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let channel_info = d.list_channels()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(channel_info);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListChannels", Default::default(), h);
+    let m = m.out_arg(("Channel_Info", "a(osuu)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handle_type: u32 = i.read()?;
+        let handles: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        d.release_handles(handle_type, handles)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReleaseHandles", Default::default(), h);
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let type_: &str = i.read()?;
+        let handle_type: u32 = i.read()?;
+        let handle: u32 = i.read()?;
+        let suppress_handler: bool = i.read()?;
+        let d = fclone(minfo);
+        let object_path = d.request_channel(type_, handle_type, handle, suppress_handler)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(object_path);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestChannel", Default::default(), h);
+    let m = m.in_arg(("Type", "s"));
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handle", "u"));
+    let m = m.in_arg(("Suppress_Handler", "b"));
+    let m = m.out_arg(("Object_Path", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handle_type: u32 = i.read()?;
+        let identifiers: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        let handles = d.request_handles(handle_type, identifiers)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestHandles", Default::default(), h);
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Identifiers", "as"));
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tokens: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        d.add_client_interest(tokens)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddClientInterest", Default::default(), h);
+    let m = m.in_arg(("Tokens", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tokens: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        d.remove_client_interest(tokens)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveClientInterest", Default::default(), h);
+    let m = m.in_arg(("Tokens", "as"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SelfHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.self_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("SelfID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.self_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Status", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.status()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasImmortalHandles", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.has_immortal_handles()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SelfHandleChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("SelfContactChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let s = s.arg(("Self_ID", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("NewChannel", Default::default());
+    let s = s.arg(("Object_Path", "o"));
+    let s = s.arg(("Channel_Type", "s"));
+    let s = s.arg(("Handle_Type", "u"));
+    let s = s.arg(("Handle", "u"));
+    let s = s.arg(("Suppress_Handler", "b"));
+    let i = i.add_s(s);
+    let s = factory.signal("ConnectionError", Default::default());
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("StatusChanged", Default::default());
+    let s = s.arg(("Status", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionSelfHandleChanged {
+    pub self_handle: u32,
+}
+
+impl arg::AppendAll for ConnectionSelfHandleChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionSelfHandleChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionSelfHandleChanged {
+            self_handle: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionSelfHandleChanged {
+    const NAME: &'static str = "SelfHandleChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection";
+}
+
+#[derive(Debug)]
+pub struct ConnectionSelfContactChanged {
+    pub self_handle: u32,
+    pub self_id: String,
+}
+
+impl arg::AppendAll for ConnectionSelfContactChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+        arg::RefArg::append(&self.self_id, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionSelfContactChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionSelfContactChanged {
+            self_handle: i.read()?,
+            self_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionSelfContactChanged {
+    const NAME: &'static str = "SelfContactChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection";
+}
+
+#[derive(Debug)]
+pub struct ConnectionNewChannel {
+    pub object_path: dbus::Path<'static>,
+    pub channel_type: String,
+    pub handle_type: u32,
+    pub handle: u32,
+    pub suppress_handler: bool,
+}
+
+impl arg::AppendAll for ConnectionNewChannel {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.object_path, i);
+        arg::RefArg::append(&self.channel_type, i);
+        arg::RefArg::append(&self.handle_type, i);
+        arg::RefArg::append(&self.handle, i);
+        arg::RefArg::append(&self.suppress_handler, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionNewChannel {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionNewChannel {
+            object_path: i.read()?,
+            channel_type: i.read()?,
+            handle_type: i.read()?,
+            handle: i.read()?,
+            suppress_handler: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionNewChannel {
+    const NAME: &'static str = "NewChannel";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection";
+}
+
+#[derive(Debug)]
+pub struct ConnectionConnectionError {
+    pub error: String,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ConnectionConnectionError {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionConnectionError {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionConnectionError {
+            error: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionConnectionError {
+    const NAME: &'static str = "ConnectionError";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection";
+}
+
+#[derive(Debug)]
+pub struct ConnectionStatusChanged {
+    pub status: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ConnectionStatusChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.status, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionStatusChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionStatusChanged {
+            status: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionStatusChanged {
+    const NAME: &'static str = "StatusChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection";
+}

src/telepathy/connection_interface_addressing.rs

@@ -0,0 +1,95 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_addressing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceAddressing1 {
+    fn get_contacts_by_vcard_field(
+        &self,
+        field: &str,
+        addresses: Vec<&str>,
+        interfaces: Vec<&str>,
+    ) -> Result<
+        (
+            ::std::collections::HashMap<String, u32>,
+            ::std::collections::HashMap<
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            >,
+        ),
+        tree::MethodErr,
+    >;
+    fn get_contacts_by_uri(
+        &self,
+        uris: Vec<&str>,
+        interfaces: Vec<&str>,
+    ) -> Result<
+        (
+            ::std::collections::HashMap<String, u32>,
+            ::std::collections::HashMap<
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            >,
+        ),
+        tree::MethodErr,
+    >;
+}
+
+pub fn connection_interface_addressing1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: ConnectionInterfaceAddressing1,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Addressing1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let field: &str = i.read()?;
+        let addresses: Vec<&str> = i.read()?;
+        let interfaces: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        let (requested, attributes) =
+            d.get_contacts_by_vcard_field(field, addresses, interfaces)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(requested);
+        let rm = rm.append1(attributes);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetContactsByVCardField", Default::default(), h);
+    let m = m.in_arg(("Field", "s"));
+    let m = m.in_arg(("Addresses", "as"));
+    let m = m.in_arg(("Interfaces", "as"));
+    let m = m.out_arg(("Requested", "a{su}"));
+    let m = m.out_arg(("Attributes", "a{ua{sv}}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let uris: Vec<&str> = i.read()?;
+        let interfaces: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        let (requested, attributes) = d.get_contacts_by_uri(uris, interfaces)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(requested);
+        let rm = rm.append1(attributes);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetContactsByURI", Default::default(), h);
+    let m = m.in_arg(("URIs", "as"));
+    let m = m.in_arg(("Interfaces", "as"));
+    let m = m.out_arg(("Requested", "a{su}"));
+    let m = m.out_arg(("Attributes", "a{ua{sv}}"));
+    let i = i.add_m(m);
+    i
+}

src/telepathy/connection_interface_aliasing.rs

@@ -0,0 +1,116 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Aliasing.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_aliasing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceAliasing {
+    fn get_alias_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn request_aliases(&self, contacts: Vec<u32>) -> Result<Vec<String>, tree::MethodErr>;
+    fn get_aliases(
+        &self,
+        contacts: Vec<u32>,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn set_aliases(
+        &self,
+        aliases: ::std::collections::HashMap<u32, &str>,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn connection_interface_aliasing_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceAliasing,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Aliasing",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let alias_flags = d.get_alias_flags()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(alias_flags);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAliasFlags", Default::default(), h);
+    let m = m.out_arg(("Alias_Flags", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let aliases = d.request_aliases(contacts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(aliases);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestAliases", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.out_arg(("Aliases", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let aliases = d.get_aliases(contacts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(aliases);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAliases", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.out_arg(("Aliases", "a{us}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let aliases: ::std::collections::HashMap<u32, &str> = i.read()?;
+        let d = fclone(minfo);
+        d.set_aliases(aliases)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetAliases", Default::default(), h);
+    let m = m.in_arg(("Aliases", "a{us}"));
+    let i = i.add_m(m);
+    let s = factory.signal("AliasesChanged", Default::default());
+    let s = s.arg(("Aliases", "a(us)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceAliasingAliasesChanged {
+    pub aliases: Vec<(u32, String)>,
+}
+
+impl arg::AppendAll for ConnectionInterfaceAliasingAliasesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.aliases, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceAliasingAliasesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceAliasingAliasesChanged { aliases: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceAliasingAliasesChanged {
+    const NAME: &'static str = "AliasesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
+}

src/telepathy/connection_interface_anonymity.rs

@@ -0,0 +1,104 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Anonymity.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_anonymity.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceAnonymity {
+    fn supported_anonymity_modes(&self) -> Result<u32, tree::MethodErr>;
+    fn anonymity_mandatory(&self) -> Result<bool, tree::MethodErr>;
+    fn set_anonymity_mandatory(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn anonymity_modes(&self) -> Result<u32, tree::MethodErr>;
+    fn set_anonymity_modes(&self, value: u32) -> Result<(), tree::MethodErr>;
+}
+
+pub fn connection_interface_anonymity_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceAnonymity,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Anonymity",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("SupportedAnonymityModes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_anonymity_modes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("AnonymityMandatory", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymity_mandatory()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_anonymity_mandatory(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("AnonymityModes", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.anonymity_modes()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_anonymity_modes(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AnonymityModesChanged", Default::default());
+    let s = s.arg(("Modes", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceAnonymityAnonymityModesChanged {
+    pub modes: u32,
+}
+
+impl arg::AppendAll for ConnectionInterfaceAnonymityAnonymityModesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.modes, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceAnonymityAnonymityModesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceAnonymityAnonymityModesChanged { modes: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceAnonymityAnonymityModesChanged {
+    const NAME: &'static str = "AnonymityModesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Anonymity";
+}

src/telepathy/connection_interface_avatars.rs

@@ -0,0 +1,315 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Avatars.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_avatars.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceAvatars {
+    fn get_avatar_requirements(
+        &self,
+    ) -> Result<(Vec<String>, u16, u16, u16, u16, u32), tree::MethodErr>;
+    fn get_avatar_tokens(&self, contacts: Vec<u32>) -> Result<Vec<String>, tree::MethodErr>;
+    fn get_known_avatar_tokens(
+        &self,
+        contacts: Vec<u32>,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn request_avatar(&self, contact: u32) -> Result<(Vec<u8>, String), tree::MethodErr>;
+    fn request_avatars(&self, contacts: Vec<u32>) -> Result<(), tree::MethodErr>;
+    fn set_avatar(&self, avatar: Vec<u8>, mimetype: &str) -> Result<String, tree::MethodErr>;
+    fn clear_avatar(&self) -> Result<(), tree::MethodErr>;
+    fn supported_avatar_mimetypes(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn minimum_avatar_height(&self) -> Result<u32, tree::MethodErr>;
+    fn minimum_avatar_width(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_avatar_height(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_avatar_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_avatar_height(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_avatar_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_avatar_bytes(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn connection_interface_avatars_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceAvatars,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Avatars",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let (mimetypes, min_width, min_height, max_width, max_height, max_bytes) =
+            d.get_avatar_requirements()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(mimetypes);
+        let rm = rm.append1(min_width);
+        let rm = rm.append1(min_height);
+        let rm = rm.append1(max_width);
+        let rm = rm.append1(max_height);
+        let rm = rm.append1(max_bytes);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAvatarRequirements", Default::default(), h);
+    let m = m.out_arg(("MIME_Types", "as"));
+    let m = m.out_arg(("Min_Width", "q"));
+    let m = m.out_arg(("Min_Height", "q"));
+    let m = m.out_arg(("Max_Width", "q"));
+    let m = m.out_arg(("Max_Height", "q"));
+    let m = m.out_arg(("Max_Bytes", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let tokens = d.get_avatar_tokens(contacts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(tokens);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAvatarTokens", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.out_arg(("Tokens", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let tokens = d.get_known_avatar_tokens(contacts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(tokens);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetKnownAvatarTokens", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.out_arg(("Tokens", "a{us}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contact: u32 = i.read()?;
+        let d = fclone(minfo);
+        let (data, mimetype) = d.request_avatar(contact)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(data);
+        let rm = rm.append1(mimetype);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestAvatar", Default::default(), h);
+    let m = m.in_arg(("Contact", "u"));
+    let m = m.out_arg(("Data", "ay"));
+    let m = m.out_arg(("MIME_Type", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        d.request_avatars(contacts)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestAvatars", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let avatar: Vec<u8> = i.read()?;
+        let mimetype: &str = i.read()?;
+        let d = fclone(minfo);
+        let token = d.set_avatar(avatar, mimetype)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(token);
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetAvatar", Default::default(), h);
+    let m = m.in_arg(("Avatar", "ay"));
+    let m = m.in_arg(("MIME_Type", "s"));
+    let m = m.out_arg(("Token", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        d.clear_avatar()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ClearAvatar", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedAvatarMIMETypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_avatar_mimetypes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumAvatarHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.minimum_avatar_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumAvatarWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.minimum_avatar_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedAvatarHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.recommended_avatar_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedAvatarWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.recommended_avatar_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumAvatarHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_avatar_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumAvatarWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_avatar_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumAvatarBytes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.maximum_avatar_bytes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AvatarUpdated", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("New_Avatar_Token", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("AvatarRetrieved", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("Token", "s"));
+    let s = s.arg(("Avatar", "ay"));
+    let s = s.arg(("Type", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceAvatarsAvatarUpdated {
+    pub contact: u32,
+    pub new_avatar_token: String,
+}
+
+impl arg::AppendAll for ConnectionInterfaceAvatarsAvatarUpdated {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.new_avatar_token, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceAvatarsAvatarUpdated {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceAvatarsAvatarUpdated {
+            contact: i.read()?,
+            new_avatar_token: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceAvatarsAvatarUpdated {
+    const NAME: &'static str = "AvatarUpdated";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Avatars";
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceAvatarsAvatarRetrieved {
+    pub contact: u32,
+    pub token: String,
+    pub avatar: Vec<u8>,
+    pub type_: String,
+}
+
+impl arg::AppendAll for ConnectionInterfaceAvatarsAvatarRetrieved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.token, i);
+        arg::RefArg::append(&self.avatar, i);
+        arg::RefArg::append(&self.type_, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceAvatarsAvatarRetrieved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceAvatarsAvatarRetrieved {
+            contact: i.read()?,
+            token: i.read()?,
+            avatar: i.read()?,
+            type_: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceAvatarsAvatarRetrieved {
+    const NAME: &'static str = "AvatarRetrieved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Avatars";
+}

src/telepathy/connection_interface_balance.rs

@@ -0,0 +1,76 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Balance.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_balance.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceBalance {
+    fn account_balance(&self) -> Result<(i32, u32, String), tree::MethodErr>;
+    fn manage_credit_uri(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn connection_interface_balance_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceBalance,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Balance",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(i32, u32, &str), _>("AccountBalance", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.account_balance()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ManageCreditURI", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.manage_credit_uri()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("BalanceChanged", Default::default());
+    let s = s.arg(("Balance", "(ius)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceBalanceBalanceChanged {
+    pub balance: (i32, u32, String),
+}
+
+impl arg::AppendAll for ConnectionInterfaceBalanceBalanceChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.balance, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceBalanceBalanceChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceBalanceBalanceChanged { balance: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceBalanceBalanceChanged {
+    const NAME: &'static str = "BalanceChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Balance";
+}

src/telepathy/connection_interface_capabilities.rs

@@ -0,0 +1,92 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Capabilities.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_capabilities.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceCapabilities {
+    fn advertise_capabilities(
+        &self,
+        add: Vec<(&str, u32)>,
+        remove: Vec<&str>,
+    ) -> Result<Vec<(String, u32)>, tree::MethodErr>;
+    fn get_capabilities(
+        &self,
+        handles: Vec<u32>,
+    ) -> Result<Vec<(u32, String, u32, u32)>, tree::MethodErr>;
+}
+
+pub fn connection_interface_capabilities_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceCapabilities,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Capabilities",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let add: Vec<(&str, u32)> = i.read()?;
+        let remove: Vec<&str> = i.read()?;
+        let d = fclone(minfo);
+        let self_capabilities = d.advertise_capabilities(add, remove)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(self_capabilities);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AdvertiseCapabilities", Default::default(), h);
+    let m = m.in_arg(("Add", "a(su)"));
+    let m = m.in_arg(("Remove", "as"));
+    let m = m.out_arg(("Self_Capabilities", "a(su)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handles: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let contact_capabilities = d.get_capabilities(handles)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(contact_capabilities);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCapabilities", Default::default(), h);
+    let m = m.in_arg(("Handles", "au"));
+    let m = m.out_arg(("Contact_Capabilities", "a(usuu)"));
+    let i = i.add_m(m);
+    let s = factory.signal("CapabilitiesChanged", Default::default());
+    let s = s.arg(("Caps", "a(usuuuu)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceCapabilitiesCapabilitiesChanged {
+    pub caps: Vec<(u32, String, u32, u32, u32, u32)>,
+}
+
+impl arg::AppendAll for ConnectionInterfaceCapabilitiesCapabilitiesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.caps, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceCapabilitiesCapabilitiesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceCapabilitiesCapabilitiesChanged { caps: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceCapabilitiesCapabilitiesChanged {
+    const NAME: &'static str = "CapabilitiesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
+}

src/telepathy/connection_interface_cellular.rs

@@ -0,0 +1,164 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Cellular.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_cellular.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceCellular {
+    fn message_validity_period(&self) -> Result<u32, tree::MethodErr>;
+    fn set_message_validity_period(&self, value: u32) -> Result<(), tree::MethodErr>;
+    fn override_message_service_centre(&self) -> Result<bool, tree::MethodErr>;
+    fn set_override_message_service_centre(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn message_service_centre(&self) -> Result<String, tree::MethodErr>;
+    fn set_message_service_centre(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn imsi(&self) -> Result<String, tree::MethodErr>;
+    fn message_reduced_character_set(&self) -> Result<bool, tree::MethodErr>;
+    fn set_message_reduced_character_set(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn message_national_character_set(&self) -> Result<String, tree::MethodErr>;
+    fn set_message_national_character_set(&self, value: String) -> Result<(), tree::MethodErr>;
+}
+
+pub fn connection_interface_cellular_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceCellular,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.Cellular",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("MessageValidityPeriod", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_validity_period()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_message_validity_period(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("OverrideMessageServiceCentre", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.override_message_service_centre()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_override_message_service_centre(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("MessageServiceCentre", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_service_centre()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_message_service_centre(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("IMSI", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.imsi()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("MessageReducedCharacterSet", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_reduced_character_set()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_message_reduced_character_set(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("MessageNationalCharacterSet", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.message_national_character_set()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        d.set_message_national_character_set(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("IMSIChanged", Default::default());
+    let s = s.arg(("IMSI", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceCellularIMSIChanged {
+    pub imsi: String,
+}
+
+impl arg::AppendAll for ConnectionInterfaceCellularIMSIChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.imsi, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceCellularIMSIChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceCellularIMSIChanged { imsi: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceCellularIMSIChanged {
+    const NAME: &'static str = "IMSIChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Cellular";
+}

src/telepathy/connection_interface_client_types.rs

@@ -0,0 +1,92 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Client_Types.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_client_types.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceClientTypes {
+    fn get_client_types(
+        &self,
+        contacts: Vec<u32>,
+    ) -> Result<::std::collections::HashMap<u32, Vec<String>>, tree::MethodErr>;
+    fn request_client_types(&self, contact: u32) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn connection_interface_client_types_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceClientTypes,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.ClientTypes",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let d = fclone(minfo);
+        let client_types = d.get_client_types(contacts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(client_types);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetClientTypes", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.out_arg(("Client_Types", "a{uas}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contact: u32 = i.read()?;
+        let d = fclone(minfo);
+        let client_types = d.request_client_types(contact)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(client_types);
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestClientTypes", Default::default(), h);
+    let m = m.in_arg(("Contact", "u"));
+    let m = m.out_arg(("Client_Types", "as"));
+    let i = i.add_m(m);
+    let s = factory.signal("ClientTypesUpdated", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("Client_Types", "as"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceClientTypesClientTypesUpdated {
+    pub contact: u32,
+    pub client_types: Vec<String>,
+}
+
+impl arg::AppendAll for ConnectionInterfaceClientTypesClientTypesUpdated {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.client_types, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceClientTypesClientTypesUpdated {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceClientTypesClientTypesUpdated {
+            contact: i.read()?,
+            client_types: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceClientTypesClientTypesUpdated {
+    const NAME: &'static str = "ClientTypesUpdated";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ClientTypes";
+}

src/telepathy/connection_interface_communication_policy.rs

@@ -0,0 +1,106 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Communication_Policy.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_communication_policy.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ConnectionInterfaceCommunicationPolicyDRAFT {
+    fn set_policy(
+        &self,
+        channel_type: &str,
+        policy: (u32, arg::Variant<Box<dyn arg::RefArg>>),
+    ) -> Result<(), tree::MethodErr>;
+    fn supported_policies(&self) -> Result<Vec<(Vec<String>, Vec<u32>)>, tree::MethodErr>;
+    fn active_policies(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, (u32, arg::Variant<Box<dyn arg::RefArg + 'static>>)>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn connection_interface_communication_policy_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: ConnectionInterfaceCommunicationPolicyDRAFT,
+    F: 'static + for<'z> Fn(&'z tree::MethodInfo<tree::MTFn<D>, D>) -> &'z T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Connection.Interface.CommunicationPolicy.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel_type: &str = i.read()?;
+        let policy: (u32, arg::Variant<Box<dyn arg::RefArg>>) = i.read()?;
+        let d = fclone(minfo);
+        d.set_policy(channel_type, policy)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetPolicy", Default::default(), h);
+    let m = m.in_arg(("Channel_Type", "s"));
+    let m = m.in_arg(("Policy", "(uv)"));
+    let i = i.add_m(m);
+
+    let p =
+        factory.property::<Vec<(Vec<&str>, Vec<u32>)>, _>("SupportedPolicies", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.supported_policies()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<&str, (u32, arg::Variant<Box<dyn arg::RefArg>>)>, _>("ActivePolicies", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(d.active_policies()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("PolicyChanged", Default::default());
+    let s = s.arg(("Changed_Policies", "a{s(uv)}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged {
+    pub changed_policies:
+        ::std::collections::HashMap<String, (u32, arg::Variant<Box<dyn arg::RefArg + 'static>>)>,
+}
+
+impl arg::AppendAll for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.changed_policies, i);
+    }
+}
+
+impl arg::ReadAll for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged {
+            changed_policies: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged {
+    const NAME: &'static str = "PolicyChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Connection.Interface.CommunicationPolicy.DRAFT";
+}