feat(filamento): disco features and identity categories according to registry

2 files changed, 1643 insertions, 0 deletions

diff --git a/filamento/src/disco.rs b/filamento/src/disco.rs
new file mode 100644
index 0000000..233dd5f
--- /dev/null
+++ b/filamento/src/disco.rs
@@ -0,0 +1,1640 @@
+use stanza::xep_0030::info;
+
+pub use feature::Feature;
+pub use identity::Identity;
+
+pub struct Info {
+    node: Option<String>,
+    features: Vec<Feature>,
+    identities: Vec<Identity>,
+}
+
+mod feature {
+    // https://xmpp.org/registrar/disco-features.html
+    pub enum Feature {
+        DNSSRV,
+        FullUnicode,
+        GC1,
+        Activity,
+        Address,
+        Amp(Option<Amp>),
+        Bytestreams(Option<Bytestreams>),
+        Caps(CapsVersion),
+        ChatStates,
+        Commands,
+        Compress,
+        Disco(Disco),
+        FeatureNeg,
+        Geoloc,
+        HttpAuth,
+        HttpBind,
+        IBB,
+        Mood,
+        MUC(Option<MUC>),
+        Offline,
+        PubSub(PubSub),
+        RosterX,
+        SIPub,
+        SOAP(Option<SOAP>),
+        WaitingList(Option<WaitingList>),
+        XHTMLIM,
+        XDataLayout,
+        XDataValidate,
+        IPv6,
+        Client,
+        Component(Component),
+        Iq(Iq),
+        Server,
+        X(X),
+        MsgLog,
+        MsgOffline,
+        RosterDelimiter,
+        SSLC2S,
+        StringPrep,
+        XMPPBind,
+        XMPPE2E,
+        XMPPSASL(Option<XMPPSASL>),
+        XMPPSession,
+        XMPPStanzas,
+        XMPPStreams,
+        XMPPTLS(Option<XMPPTLS>),
+        RFC3264,
+        Archive(Archive),
+        Avatar(Avatar),
+        Delay,
+        Jingle(Jingle),
+        Ping,
+        Receipts,
+        SSN,
+        Time,
+        XMLLang,
+        VCardTemp,
+        Styling(i8),
+        SID(i8),
+        Unknown(String),
+    }
+
+    impl From<&str> for Feature {
+        fn from(value: &str) -> Self {
+            match value {
+                "dnssrv" => Self::DNSSRV,
+                "fullunicode" => Self::FullUnicode,
+                "gc-1.0" => Self::GC1,
+                "http://jabber.org/protocol/activity" => Self::Activity,
+                "http://jabber.org/protocol/address" => Self::Address,
+                "http://jabber.org/protocol/amp" => Self::Amp(None),
+                "http://jabber.org/protocol/amp#errors" => Self::Amp(Some(Amp::Errors)),
+                "http://jabber.org/protocol/amp?action=alert" => {
+                    Self::Amp(Some(Amp::Action(AmpAction::Alert)))
+                }
+                "http://jabber.org/protocol/amp?action=drop" => {
+                    Self::Amp(Some(Amp::Action(AmpAction::Drop)))
+                }
+                "http://jabber.org/protocol/amp?action=error" => {
+                    Self::Amp(Some(Amp::Action(AmpAction::Error)))
+                }
+                "http://jabber.org/protocol/amp?action=notify" => {
+                    Self::Amp(Some(Amp::Action(AmpAction::Notify)))
+                }
+                "http://jabber.org/protocol/amp?condition=deliver" => {
+                    Self::Amp(Some(Amp::Condition(AmpCondition::Deliver)))
+                }
+                "http://jabber.org/protocol/amp?condition=expire-at" => {
+                    Self::Amp(Some(Amp::Condition(AmpCondition::ExpireAt)))
+                }
+                "http://jabber.org/protocol/amp?condition=match-resource" => {
+                    Self::Amp(Some(Amp::Condition(AmpCondition::MatchResource)))
+                }
+                "http://jabber.org/protocol/bytestreams" => Self::Bytestreams(None),
+                "http://jabber.org/protocol/bytestreams#udp" => {
+                    Self::Bytestreams(Some(Bytestreams::UDP))
+                }
+                "http://jabber.org/protocol/caps" => Self::Caps(CapsVersion::One(None)),
+                "http://jabber.org/protocol/caps#optimize" => {
+                    Self::Caps(CapsVersion::One(Some(CapsOne::Optimize)))
+                }
+                "http://jabber.org/protocol/chatstates" => Self::ChatStates,
+                "http://jabber.org/protocol/commands" => Self::Commands,
+                "http://jabber.org/protocol/compress" => Self::Compress,
+                "http://jabber.org/protocol/disco#info" => Self::Disco(Disco::Info),
+                "http://jabber.org/protocol/disco#items" => Self::Disco(Disco::Items),
+                "http://jabber.org/protocol/feature-neg" => Self::FeatureNeg,
+                "http://jabber.org/protocol/geoloc" => Self::Geoloc,
+                "http://jabber.org/protocol/http-auth" => Self::HttpAuth,
+                "http://jabber.org/protocol/httpbind" => Self::HttpBind,
+                "http://jabber.org/protocol/ibb" => Self::IBB,
+                "http://jabber.org/protocol/mood" => Self::Mood,
+                "http://jabber.org/protocol/muc" => Self::MUC(None),
+                "http://jabber.org/protocol/muc#admin" => Self::MUC(Some(MUC::Admin)),
+                "http://jabber.org/protocol/muc#owner" => Self::MUC(Some(MUC::Owner)),
+                "http://jabber.org/protocol/muc#register" => Self::MUC(Some(MUC::Register)),
+                "http://jabber.org/protocol/muc#roomconfig" => Self::MUC(Some(MUC::RoomConfig)),
+                "http://jabber.org/protocol/muc#roominfo" => Self::MUC(Some(MUC::RoomInfo)),
+                "http://jabber.org/protocol/muc#user" => Self::MUC(Some(MUC::User)),
+                "http://jabber.org/protocol/offline" => Self::Offline,
+                "http://jabber.org/protocol/pubsub#access-authorize" => {
+                    Self::PubSub(PubSub::AccessAuthorize)
+                }
+                "http://jabber.org/protocol/pubsub#access-open" => Self::PubSub(PubSub::AccessOpen),
+                "http://jabber.org/protocol/pubsub#access-presence" => {
+                    Self::PubSub(PubSub::AccessPresence)
+                }
+                "http://jabber.org/protocol/pubsub#access-roster" => {
+                    Self::PubSub(PubSub::AccessRoster)
+                }
+                "http://jabber.org/protocol/pubsub#access-whitelist" => {
+                    Self::PubSub(PubSub::AccessWhitelist)
+                }
+                "http://jabber.org/protocol/pubsub#auto-create" => Self::PubSub(PubSub::AutoCreate),
+                "http://jabber.org/protocol/pubsub#auto-subscribe" => {
+                    Self::PubSub(PubSub::AutoSubscribe)
+                }
+                "http://jabber.org/protocol/pubsub#collections" => {
+                    Self::PubSub(PubSub::Collections)
+                }
+                "http://jabber.org/protocol/pubsub#config-node" => Self::PubSub(PubSub::ConfigNode),
+                "http://jabber.org/protocol/pubsub#create-and-configure" => {
+                    Self::PubSub(PubSub::CreateAndConfigure)
+                }
+                "http://jabber.org/protocol/pubsub#create-nodes" => {
+                    Self::PubSub(PubSub::CreateNodes)
+                }
+                "http://jabber.org/protocol/pubsub#delete-any" => Self::PubSub(PubSub::DeleteAny),
+                "http://jabber.org/protocol/pubsub#delete-nodes" => {
+                    Self::PubSub(PubSub::DeleteNodes)
+                }
+                "http://jabber.org/protocol/pubsub#filtered-notifications" => {
+                    Self::PubSub(PubSub::FilteredNotifications)
+                }
+                "http://jabber.org/protocol/pubsub#get-pending" => Self::PubSub(PubSub::GetPending),
+                "http://jabber.org/protocol/pubsub#instant-nodes" => {
+                    Self::PubSub(PubSub::InstantNodes)
+                }
+                "http://jabber.org/protocol/pubsub#item-ids" => Self::PubSub(PubSub::ItemIDs),
+                "http://jabber.org/protocol/pubsub#last-published" => {
+                    Self::PubSub(PubSub::LastPublished)
+                }
+                "http://jabber.org/protocol/pubsub#leased-subscription" => {
+                    Self::PubSub(PubSub::LeasedSubscription)
+                }
+                "http://jabber.org/protocol/pubsub#manage-subscription" => {
+                    Self::PubSub(PubSub::ManageSubscription)
+                }
+                "http://jabber.org/protocol/pubsub#member-affiliation" => {
+                    Self::PubSub(PubSub::MemberAffiliation)
+                }
+                "http://jabber.org/protocol/pubsub#meta-data" => Self::PubSub(PubSub::MetaData),
+                "http://jabber.org/protocol/pubsub#modify-affiliations" => {
+                    Self::PubSub(PubSub::ModifyAffiliations)
+                }
+                "http://jabber.org/protocol/pubsub#multi-collection" => {
+                    Self::PubSub(PubSub::MultiCollection)
+                }
+                "http://jabber.org/protocol/pubsub#multi-subscribe" => {
+                    Self::PubSub(PubSub::MultiSubscribe)
+                }
+                "http://jabber.org/protocol/pubsub#outcast-affiliation" => {
+                    Self::PubSub(PubSub::OutcastAffiliation)
+                }
+                "http://jabber.org/protocol/pubsub#persistent-items" => {
+                    Self::PubSub(PubSub::PersistentItems)
+                }
+                "http://jabber.org/protocol/pubsub#presence-notifications" => {
+                    Self::PubSub(PubSub::PresenceNotifications)
+                }
+                "http://jabber.org/protocol/pubsub#presence-subscribe" => {
+                    Self::PubSub(PubSub::PresenceSubscribe)
+                }
+                "http://jabber.org/protocol/pubsub#publish" => Self::PubSub(PubSub::Publish),
+                "http://jabber.org/protocol/pubsub#publish-options" => {
+                    Self::PubSub(PubSub::PublishOptions)
+                }
+                "http://jabber.org/protocol/pubsub#publisher-affiliation" => {
+                    Self::PubSub(PubSub::PublisherAffiliation)
+                }
+                "http://jabber.org/protocol/pubsub#purge-nodes" => Self::PubSub(PubSub::PurgeNodes),
+                "http://jabber.org/protocol/pubsub#retract-items" => {
+                    Self::PubSub(PubSub::RetractItems)
+                }
+                "http://jabber.org/protocol/pubsub#retrieve-affiliations" => {
+                    Self::PubSub(PubSub::RetrieveAffiliations)
+                }
+                "http://jabber.org/protocol/pubsub#retrieve-default" => {
+                    Self::PubSub(PubSub::RetrieveDefault)
+                }
+                "http://jabber.org/protocol/pubsub#retrieve-items" => {
+                    Self::PubSub(PubSub::RetrieveItems)
+                }
+                "http://jabber.org/protocol/pubsub#retrieve-subscriptions" => {
+                    Self::PubSub(PubSub::RetrieveSubscriptions)
+                }
+                "http://jabber.org/protocol/pubsub#subscribe" => Self::PubSub(PubSub::Subscribe),
+                "http://jabber.org/protocol/pubsub#subscription-options" => {
+                    Self::PubSub(PubSub::SubscriptionOptions)
+                }
+                "http://jabber.org/protocol/pubsub#subscription-notifications" => {
+                    Self::PubSub(PubSub::SubscriptionNotifications)
+                }
+                "http://jabber.org/protocol/rosterx" => Self::RosterX,
+                "http://jabber.org/protocol/sipub" => Self::SIPub,
+                "http://jabber.org/protocol/soap" => Self::SOAP(None),
+                "http://jabber.org/protocol/soap#fault" => Self::SOAP(Some(SOAP::Fault)),
+                "http://jabber.org/protocol/waitinglist" => Self::WaitingList(None),
+                "http://jabber.org/protocol/waitinglist/schemes/mailto" => {
+                    Self::WaitingList(Some(WaitingList::Schemes(WaitingListSchemes::Mailto)))
+                }
+                "http://jabber.org/protocol/waitinglist/schemes/tel" => {
+                    Self::WaitingList(Some(WaitingList::Schemes(WaitingListSchemes::Tel)))
+                }
+                "http://jabber.org/protocol/xhtml-im" => Self::XHTMLIM,
+                "http://jabber.org/protocol/xdata-layout" => Self::XDataLayout,
+                "http://jabber.org/protocol/xdata-validate" => Self::XDataValidate,
+                "ipv6" => Self::IPv6,
+                "jabber:client" => Self::Client,
+                "jabber:component:accept" => Self::Component(Component::Accept),
+                "jabber:component:connect" => Self::Component(Component::Connect),
+                "jabber:iq:auth" => Self::Iq(Iq::Auth),
+                "jabber:iq:gateway" => Self::Iq(Iq::Gateway),
+                "jabber:iq:last" => Self::Iq(Iq::Last),
+                "jabber:iq:oob" => Self::Iq(Iq::OOB),
+                "jabber:iq:privacy" => Self::Iq(Iq::Privacy),
+                "jabber:iq:private" => Self::Iq(Iq::Private),
+                "jabber:iq:register" => Self::Iq(Iq::Register),
+                "jabber:iq:roster" => Self::Iq(Iq::Roster),
+                "jabber:iq:rpc" => Self::Iq(Iq::RPC),
+                "jabber:iq:search" => Self::Iq(Iq::Search),
+                "jabber:iq:version" => Self::Iq(Iq::Version),
+                "jabber:server" => Self::Server,
+                "jabber:x:data" => Self::X(X::Data),
+                "jabber:x:encrypted" => Self::X(X::Encrypted),
+                "jabber:x:oob" => Self::X(X::OOB),
+                "jabber:x:signed" => Self::X(X::Signed),
+                "msglog" => Self::MsgLog,
+                "msgoffline" => Self::MsgOffline,
+                "muc_hidden" => Self::MUC(Some(MUC::Hidden)),
+                "muc_membersonly" => Self::MUC(Some(MUC::MembersOnly)),
+                "muc_moderated" => Self::MUC(Some(MUC::Moderated)),
+                "muc_nonanonymous" => Self::MUC(Some(MUC::NonAnonymous)),
+                "muc_open" => Self::MUC(Some(MUC::Open)),
+                "muc_passwordprotected" => Self::MUC(Some(MUC::PasswordProtected)),
+                "muc_persistent" => Self::MUC(Some(MUC::Persistent)),
+                "muc_public" => Self::MUC(Some(MUC::Public)),
+                "muc_rooms" => Self::MUC(Some(MUC::Rooms)),
+                "muc_semianonymous" => Self::MUC(Some(MUC::SemiAnonymous)),
+                "muc_temporary" => Self::MUC(Some(MUC::Temporary)),
+                "muc_unmoderated" => Self::MUC(Some(MUC::Unmoderated)),
+                "muc_unsecured" => Self::MUC(Some(MUC::Unsecured)),
+                "roster:delimiter" => Self::RosterDelimiter,
+                "sslc2s" => Self::SSLC2S,
+                "stringprep" => Self::StringPrep,
+                "urn:ietf:params:xml:ns:xmpp-bind" => Self::XMPPBind,
+                "urn:ietf:params:xml:ns:xmpp-e2e" => Self::XMPPE2E,
+                "urn:ietf:params:xml:ns:xmpp-sasl" => Self::XMPPSASL(None),
+                "urn:ietf:params:xml:ns:xmpp-sasl#c2s" => Self::XMPPSASL(Some(XMPPSASL::C2S)),
+                "urn:ietf:params:xml:ns:xmpp-sasl#s2s" => Self::XMPPSASL(Some(XMPPSASL::S2S)),
+                "urn:ietf:params:xml:ns:xmpp-session" => Self::XMPPSession,
+                "urn:ietf:params:xml:ns:xmpp-stanzas" => Self::XMPPStanzas,
+                "urn:ietf:params:xml:ns:xmpp-streams" => Self::XMPPStreams,
+                "urn:ietf:params:xml:ns:xmpp-tls" => Self::XMPPTLS(None),
+                "urn:ietf:params:xml:ns:xmpp-tls#c2s" => Self::XMPPTLS(Some(XMPPTLS::C2S)),
+                "urn:ietf:params:xml:ns:xmpp-tls#s2s" => Self::XMPPTLS(Some(XMPPTLS::S2S)),
+                "urn:ietf:rfc:3264" => Self::RFC3264,
+                "urn:xmpp:archive:auto" => Self::Archive(Archive::Auto),
+                "urn:xmpp:archive:manage" => Self::Archive(Archive::Manage),
+                "urn:xmpp:archive:manual" => Self::Archive(Archive::Manual),
+                "urn:xmpp:archive:pref" => Self::Archive(Archive::Pref),
+                "urn:xmpp:avatar:data" => Self::Avatar(Avatar::Data),
+                "urn:xmpp:avatar:metadata" => Self::Avatar(Avatar::Metadata),
+                "urn:xmpp:delay" => Self::Delay,
+                "urn:xmpp:jingle:apps:rtp:audio" => {
+                    Self::Jingle(Jingle::Apps(JingleApps::RTP(JingleAppsRTP::Audio)))
+                }
+                "urn:xmpp:jingle:apps:rtp:video" => {
+                    Self::Jingle(Jingle::Apps(JingleApps::RTP(JingleAppsRTP::Video)))
+                }
+                "urn:xmpp:ping" => Self::Ping,
+                "urn:xmpp:receipts" => Self::Receipts,
+                "urn:xmpp:ssn" => Self::SSN,
+                "urn:xmpp:time" => Self::Time,
+                "xmllang" => Self::XMLLang,
+                "vcard-temp" => Self::VCardTemp,
+                "urn:xmpp:styling:0" => Self::Styling(0),
+                "urn:xmpp:sid:0" => Self::SID(0),
+                "urn:xmpp:caps" => Self::Caps(CapsVersion::Two(None)),
+                "urn:xmpp:caps:optimize" => Self::Caps(CapsVersion::Two(Some(CapsTwo::Optimize))),
+                s => Self::Unknown(s.to_owned()),
+            }
+        }
+    }
+
+    impl ToString for Feature {
+        fn to_string(&self) -> String {
+            match self {
+                Feature::DNSSRV => "dnssrv".to_owned(),
+                Feature::FullUnicode => "fullunicode".to_owned(),
+                Feature::GC1 => "gc-1.0".to_owned(),
+                Feature::Activity => "http://jabber.org/protocol/activity".to_owned(),
+                Feature::Address => "http://jabber.org/protocol/address".to_owned(),
+                Feature::Amp(amp) => match amp {
+                    Some(a) => a.to_string(),
+                    None => "http://jabber.org/protocol/amp".to_owned(),
+                },
+                Feature::Bytestreams(byte_streams) => match byte_streams {
+                    Some(b) => b.to_string(),
+                    None => "http://jabber.org/protocol/bytestreams".to_owned(),
+                },
+                Feature::Caps(caps_version) => caps_version.to_string(),
+                Feature::ChatStates => "http://jabber.org/protocol/chatstates".to_owned(),
+                Feature::Commands => "http://jabber.org/protocol/commands".to_owned(),
+                Feature::Compress => "http://jabber.org/protocol/compress".to_owned(),
+                Feature::Disco(disco) => disco.to_string(),
+                Feature::FeatureNeg => "http://jabber.org/protocol/feature-neg".to_owned(),
+                Feature::Geoloc => "http://jabber.org/protocol/geoloc".to_owned(),
+                Feature::HttpAuth => "http://jabber.org/protocol/http-auth".to_owned(),
+                Feature::HttpBind => "http://jabber.org/protocol/httpbind".to_owned(),
+                Feature::IBB => "http://jabber.org/protocol/ibb".to_owned(),
+                Feature::Mood => "http://jabber.org/protocol/mood".to_owned(),
+                Feature::MUC(muc) => match muc {
+                    Some(m) => m.to_string(),
+                    None => "http://jabber.org/protocol/muc".to_owned(),
+                },
+                Feature::Offline => "http://jabber.org/protocol/offline".to_owned(),
+                Feature::PubSub(pub_sub) => pub_sub.to_string(),
+                Feature::RosterX => "http://jabber.org/protocol/rosterx".to_owned(),
+                Feature::SIPub => "http://jabber.org/protocol/sipub".to_owned(),
+                Feature::SOAP(soap) => match soap {
+                    Some(s) => s.to_string(),
+                    None => "http://jabber.org/protocol/soap".to_owned(),
+                },
+                Feature::WaitingList(waiting_list) => match waiting_list {
+                    Some(w) => w.to_string(),
+                    None => "http://jabber.org/protocol/waitinglist".to_owned(),
+                },
+                Feature::XHTMLIM => "http://jabber.org/protocol/xhtml-im".to_owned(),
+                Feature::XDataLayout => "http://jabber.org/protocol/xdata-layout".to_owned(),
+                Feature::XDataValidate => "http://jabber.org/protocol/xdata-validate".to_owned(),
+                Feature::IPv6 => "ipv6".to_owned(),
+                Feature::Client => "jabber:client".to_owned(),
+                Feature::Component(component) => component.to_string(),
+                Feature::Iq(iq) => iq.to_string(),
+                Feature::Server => "jabber:server".to_owned(),
+                Feature::X(x) => x.to_string(),
+                Feature::MsgLog => "msglog".to_owned(),
+                Feature::MsgOffline => "msgoffline".to_owned(),
+                Feature::RosterDelimiter => "roster:delimiter".to_owned(),
+                Feature::SSLC2S => "sslc2s".to_owned(),
+                Feature::StringPrep => "stringprep".to_owned(),
+                Feature::XMPPBind => "urn:ietf:params:xml:ns:xmpp-bind".to_owned(),
+                Feature::XMPPE2E => "urn:ietf:params:xml:ns:xmpp-e2e".to_owned(),
+                Feature::XMPPSASL(xmppsasl) => match xmppsasl {
+                    Some(x) => x.to_string(),
+                    None => "urn:ietf:params:xml:ns:xmpp-sasl".to_owned(),
+                },
+                Feature::XMPPSession => "urn:ietf:params:xml:ns:xmpp-session".to_owned(),
+                Feature::XMPPStanzas => "urn:ietf:params:xml:ns:xmpp-stanzas".to_owned(),
+                Feature::XMPPStreams => "urn:ietf:params:xml:ns:xmpp-streams".to_owned(),
+                Feature::XMPPTLS(xmpptls) => match xmpptls {
+                    Some(x) => x.to_string(),
+                    None => "urn:ietf:params:xml:ns:xmpp-tls".to_owned(),
+                },
+                Feature::RFC3264 => "urn:ietf:rfc:3264".to_owned(),
+                Feature::Archive(archive) => archive.to_string(),
+                Feature::Avatar(avatar) => avatar.to_string(),
+                Feature::Delay => "urn:xmpp:delay".to_owned(),
+                Feature::Jingle(jingle) => jingle.to_string(),
+                Feature::Ping => "urn:xmpp:ping".to_owned(),
+                Feature::Receipts => "urn:xmpp:receipts".to_owned(),
+                Feature::SSN => "urn:xmpp:ssn".to_owned(),
+                Feature::Time => "urn:xmpp:time".to_owned(),
+                Feature::XMLLang => "xmllang".to_owned(),
+                Feature::VCardTemp => "vcard-temp".to_owned(),
+                Feature::Styling(_) => "urn:xmpp:styling:0".to_owned(),
+                Feature::SID(_) => "urn:xmpp:sid:0".to_owned(),
+                Feature::Unknown(s) => s.to_owned(),
+            }
+        }
+    }
+
+    pub enum Amp {
+        Errors,
+        Action(AmpAction),
+        Condition(AmpCondition),
+    }
+
+    impl ToString for Amp {
+        fn to_string(&self) -> String {
+            match self {
+                Amp::Errors => "http://jabber.org/protocol/amp#errors".to_owned(),
+                Amp::Action(amp_action) => amp_action.to_string(),
+                Amp::Condition(amp_condition) => amp_condition.to_string(),
+            }
+        }
+    }
+
+    pub enum AmpAction {
+        Alert,
+        Drop,
+        Error,
+        Notify,
+    }
+
+    impl ToString for AmpAction {
+        fn to_string(&self) -> String {
+            match self {
+                AmpAction::Alert => "http://jabber.org/protocol/amp?action=alert",
+                AmpAction::Drop => "http://jabber.org/protocol/amp?action=drop",
+                AmpAction::Error => "http://jabber.org/protocol/amp?action=error",
+                AmpAction::Notify => "http://jabber.org/protocol/amp?action=notify",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum AmpCondition {
+        Deliver,
+        ExpireAt,
+        MatchResource,
+    }
+
+    impl ToString for AmpCondition {
+        fn to_string(&self) -> String {
+            match self {
+                AmpCondition::Deliver => "http://jabber.org/protocol/amp?condition=deliver",
+                AmpCondition::ExpireAt => "http://jabber.org/protocol/amp?condition=expire-at",
+                AmpCondition::MatchResource => {
+                    "http://jabber.org/protocol/amp?condition=match-resource"
+                }
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Bytestreams {
+        UDP,
+    }
+
+    impl ToString for Bytestreams {
+        fn to_string(&self) -> String {
+            match self {
+                Bytestreams::UDP => "http://jabber.org/protocol/bytestreams#udp",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum CapsVersion {
+        One(Option<CapsOne>),
+        Two(Option<CapsTwo>),
+    }
+
+    impl ToString for CapsVersion {
+        fn to_string(&self) -> String {
+            match self {
+                CapsVersion::One(caps_one) => match caps_one {
+                    Some(c) => c.to_string(),
+                    None => "http://jabber.org/protocol/caps".to_owned(),
+                },
+                CapsVersion::Two(caps_two) => match caps_two {
+                    Some(c) => c.to_string(),
+                    None => "urn:xmpp:caps".to_owned(),
+                },
+            }
+        }
+    }
+
+    pub enum CapsOne {
+        Optimize,
+    }
+
+    impl ToString for CapsOne {
+        fn to_string(&self) -> String {
+            match self {
+                CapsOne::Optimize => "http://jabber.org/protocol/caps#optimize",
+            }
+            .to_string()
+        }
+    }
+
+    pub enum CapsTwo {
+        Optimize,
+    }
+
+    impl ToString for CapsTwo {
+        fn to_string(&self) -> String {
+            match self {
+                CapsTwo::Optimize => "urn:xmpp:caps:optimize",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Disco {
+        Info,
+        Items,
+    }
+
+    impl ToString for Disco {
+        fn to_string(&self) -> String {
+            match self {
+                Disco::Info => "http://jabber.org/protocol/disco#info",
+                Disco::Items => "http://jabber.org/protocol/disco#items",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum MUC {
+        Admin,
+        Owner,
+        Register,
+        RoomConfig,
+        RoomInfo,
+        User,
+        Hidden,
+        MembersOnly,
+        Moderated,
+        NonAnonymous,
+        Open,
+        PasswordProtected,
+        Persistent,
+        Public,
+        Rooms,
+        SemiAnonymous,
+        Temporary,
+        Unmoderated,
+        Unsecured,
+    }
+
+    impl ToString for MUC {
+        fn to_string(&self) -> String {
+            match self {
+                MUC::Admin => "http://jabber.org/protocol/muc#admin",
+                MUC::Owner => "http://jabber.org/protocol/muc#owner",
+                MUC::Register => "http://jabber.org/protocol/muc#register",
+                MUC::RoomConfig => "http://jabber.org/protocol/muc#roomconfig",
+                MUC::RoomInfo => "http://jabber.org/protocol/muc#roominfo",
+                MUC::User => "http://jabber.org/protocol/muc#user",
+                MUC::Hidden => "muc_hidden",
+                MUC::MembersOnly => "muc_membersonly",
+                MUC::Moderated => "muc_moderated",
+                MUC::NonAnonymous => "muc_nonanonymous",
+                MUC::Open => "muc_open",
+                MUC::PasswordProtected => "muc_passwordprotected",
+                MUC::Persistent => "muc_persistent",
+                MUC::Public => "muc_public",
+                MUC::Rooms => "muc_rooms",
+                MUC::SemiAnonymous => "muc_semianonymous",
+                MUC::Temporary => "muc_temporary",
+                MUC::Unmoderated => "muc_unmoderated",
+                MUC::Unsecured => "muc_unsecured",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum PubSub {
+        AccessAuthorize,
+        AccessOpen,
+        AccessPresence,
+        AccessRoster,
+        AccessWhitelist,
+        AutoCreate,
+        AutoSubscribe,
+        Collections,
+        ConfigNode,
+        CreateAndConfigure,
+        CreateNodes,
+        DeleteAny,
+        DeleteNodes,
+        FilteredNotifications,
+        GetPending,
+        InstantNodes,
+        ItemIDs,
+        LastPublished,
+        LeasedSubscription,
+        ManageSubscription,
+        MemberAffiliation,
+        MetaData,
+        ModifyAffiliations,
+        MultiCollection,
+        MultiSubscribe,
+        OutcastAffiliation,
+        PersistentItems,
+        PresenceNotifications,
+        PresenceSubscribe,
+        Publish,
+        PublishOptions,
+        PublisherAffiliation,
+        PurgeNodes,
+        RetractItems,
+        RetrieveAffiliations,
+        RetrieveDefault,
+        RetrieveItems,
+        RetrieveSubscriptions,
+        Subscribe,
+        SubscriptionOptions,
+        SubscriptionNotifications,
+    }
+
+    impl ToString for PubSub {
+        fn to_string(&self) -> String {
+            match self {
+                PubSub::AccessAuthorize => "http://jabber.org/protocol/pubsub#access-authorize",
+                PubSub::AccessOpen => "http://jabber.org/protocol/pubsub#access-open",
+                PubSub::AccessPresence => "http://jabber.org/protocol/pubsub#access-presence",
+                PubSub::AccessRoster => "http://jabber.org/protocol/pubsub#access-roster",
+                PubSub::AccessWhitelist => "http://jabber.org/protocol/pubsub#access-whitelist",
+                PubSub::AutoCreate => "http://jabber.org/protocol/pubsub#auto-create",
+                PubSub::AutoSubscribe => "http://jabber.org/protocol/pubsub#auto-subscribe",
+                PubSub::Collections => "http://jabber.org/protocol/pubsub#collections",
+                PubSub::ConfigNode => "http://jabber.org/protocol/pubsub#config-node",
+                PubSub::CreateAndConfigure => {
+                    "http://jabber.org/protocol/pubsub#create-and-configure"
+                }
+                PubSub::CreateNodes => "http://jabber.org/protocol/pubsub#create-nodes",
+                PubSub::DeleteAny => "http://jabber.org/protocol/pubsub#delete-any",
+                PubSub::DeleteNodes => "http://jabber.org/protocol/pubsub#delete-nodes",
+                PubSub::FilteredNotifications => {
+                    "http://jabber.org/protocol/pubsub#filtered-notifications"
+                }
+                PubSub::GetPending => "http://jabber.org/protocol/pubsub#get-pending",
+                PubSub::InstantNodes => "http://jabber.org/protocol/pubsub#instant-nodes",
+                PubSub::ItemIDs => "http://jabber.org/protocol/pubsub#item-ids",
+                PubSub::LastPublished => "http://jabber.org/protocol/pubsub#last-published",
+                PubSub::LeasedSubscription => {
+                    "http://jabber.org/protocol/pubsub#leased-subscription"
+                }
+                PubSub::ManageSubscription => {
+                    "http://jabber.org/protocol/pubsub#manage-subscription"
+                }
+                PubSub::MemberAffiliation => "http://jabber.org/protocol/pubsub#member-affiliation",
+                PubSub::MetaData => "http://jabber.org/protocol/pubsub#meta-data",
+                PubSub::ModifyAffiliations => {
+                    "http://jabber.org/protocol/pubsub#modify-affiliations"
+                }
+                PubSub::MultiCollection => "http://jabber.org/protocol/pubsub#multi-collection",
+                PubSub::MultiSubscribe => "http://jabber.org/protocol/pubsub#multi-subscribe",
+                PubSub::OutcastAffiliation => {
+                    "http://jabber.org/protocol/pubsub#outcast-affiliation"
+                }
+                PubSub::PersistentItems => "http://jabber.org/protocol/pubsub#persistent-items",
+                PubSub::PresenceNotifications => {
+                    "http://jabber.org/protocol/pubsub#presence-notifications"
+                }
+                PubSub::PresenceSubscribe => "http://jabber.org/protocol/pubsub#presence-subscribe",
+                PubSub::Publish => "http://jabber.org/protocol/pubsub#publish",
+                PubSub::PublishOptions => "http://jabber.org/protocol/pubsub#publish-options",
+                PubSub::PublisherAffiliation => {
+                    "http://jabber.org/protocol/pubsub#publisher-affiliation"
+                }
+                PubSub::PurgeNodes => "http://jabber.org/protocol/pubsub#purge-nodes",
+                PubSub::RetractItems => "http://jabber.org/protocol/pubsub#retract-items",
+                PubSub::RetrieveAffiliations => {
+                    "http://jabber.org/protocol/pubsub#retrieve-affiliations"
+                }
+                PubSub::RetrieveDefault => "http://jabber.org/protocol/pubsub#retrieve-default",
+                PubSub::RetrieveItems => "http://jabber.org/protocol/pubsub#retrieve-items",
+                PubSub::RetrieveSubscriptions => {
+                    "http://jabber.org/protocol/pubsub#retrieve-subscriptions"
+                }
+                PubSub::Subscribe => "http://jabber.org/protocol/pubsub#subscribe",
+                PubSub::SubscriptionOptions => {
+                    "http://jabber.org/protocol/pubsub#subscription-options"
+                }
+                PubSub::SubscriptionNotifications => {
+                    "http://jabber.org/protocol/pubsub#subscription-notifications"
+                }
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum SOAP {
+        Fault,
+    }
+
+    impl ToString for SOAP {
+        fn to_string(&self) -> String {
+            match self {
+                SOAP::Fault => "http://jabber.org/protocol/soap#fault",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum WaitingList {
+        Schemes(WaitingListSchemes),
+    }
+
+    impl ToString for WaitingList {
+        fn to_string(&self) -> String {
+            match self {
+                WaitingList::Schemes(waiting_list_schemes) => waiting_list_schemes.to_string(),
+            }
+        }
+    }
+
+    pub enum WaitingListSchemes {
+        Mailto,
+        Tel,
+    }
+
+    impl ToString for WaitingListSchemes {
+        fn to_string(&self) -> String {
+            match self {
+                WaitingListSchemes::Mailto => {
+                    "http://jabber.org/protocol/waitinglist/schemes/mailto"
+                }
+                WaitingListSchemes::Tel => "http://jabber.org/protocol/waitinglist/schemes/tel",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Component {
+        Accept,
+        Connect,
+    }
+
+    impl ToString for Component {
+        fn to_string(&self) -> String {
+            match self {
+                Component::Accept => "jabber:component:accept",
+                Component::Connect => "jabber:component:connect",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Iq {
+        Auth,
+        Gateway,
+        Last,
+        OOB,
+        Privacy,
+        Private,
+        Register,
+        Roster,
+        RPC,
+        Search,
+        Version,
+    }
+
+    impl ToString for Iq {
+        fn to_string(&self) -> String {
+            match self {
+                Iq::Auth => "jabber:iq:auth",
+                Iq::Gateway => "jabber:iq:gateway",
+                Iq::Last => "jabber:iq:last",
+                Iq::OOB => "jabber:iq:oob",
+                Iq::Privacy => "jabber:iq:privacy",
+                Iq::Private => "jabber:iq:private",
+                Iq::Register => "jabber:iq:register",
+                Iq::Roster => "jabber:iq:roster",
+                Iq::RPC => "jabber:iq:rpc",
+                Iq::Search => "jabber:iq:search",
+                Iq::Version => "jabber:iq:version",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum X {
+        Data,
+        Encrypted,
+        OOB,
+        Signed,
+    }
+
+    impl ToString for X {
+        fn to_string(&self) -> String {
+            match self {
+                X::Data => "jabber:x:data",
+                X::Encrypted => "jabber:x:encrypted",
+                X::OOB => "jabber:x:oob",
+                X::Signed => "jabber:x:signed",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum XMPPSASL {
+        C2S,
+        S2S,
+    }
+
+    impl ToString for XMPPSASL {
+        fn to_string(&self) -> String {
+            match self {
+                XMPPSASL::C2S => "urn:ietf:params:xml:ns:xmpp-sasl#c2s",
+                XMPPSASL::S2S => "urn:ietf:params:xml:ns:xmpp-sasl#s2s",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum XMPPTLS {
+        C2S,
+        S2S,
+    }
+
+    impl ToString for XMPPTLS {
+        fn to_string(&self) -> String {
+            match self {
+                XMPPTLS::C2S => "urn:ietf:params:xml:ns:xmpp-tls#c2s",
+                XMPPTLS::S2S => "urn:ietf:params:xml:ns:xmpp-tls#s2s",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Archive {
+        Auto,
+        Manage,
+        Manual,
+        Pref,
+    }
+
+    impl ToString for Archive {
+        fn to_string(&self) -> String {
+            match self {
+                Archive::Auto => "urn:xmpp:archive:auto",
+                Archive::Manage => "urn:xmpp:archive:manage",
+                Archive::Manual => "urn:xmpp:archive:manual",
+                Archive::Pref => "urn:xmpp:archive:pref",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Avatar {
+        Data,
+        Metadata,
+    }
+
+    impl ToString for Avatar {
+        fn to_string(&self) -> String {
+            match self {
+                Avatar::Data => "urn:xmpp:avatar:data",
+                Avatar::Metadata => "urn:xmpp:avatar:metadata",
+            }
+            .to_owned()
+        }
+    }
+
+    pub enum Jingle {
+        Apps(JingleApps),
+    }
+
+    impl ToString for Jingle {
+        fn to_string(&self) -> String {
+            match self {
+                Jingle::Apps(jingle_apps) => jingle_apps.to_string(),
+            }
+        }
+    }
+
+    pub enum JingleApps {
+        RTP(JingleAppsRTP),
+    }
+
+    impl ToString for JingleApps {
+        fn to_string(&self) -> String {
+            match self {
+                JingleApps::RTP(jingle_apps_rtp) => jingle_apps_rtp.to_string(),
+            }
+        }
+    }
+
+    pub enum JingleAppsRTP {
+        Audio,
+        Video,
+    }
+
+    impl ToString for JingleAppsRTP {
+        fn to_string(&self) -> String {
+            match self {
+                JingleAppsRTP::Audio => "urn:xmpp:jingle:apps:rtp:audio",
+                JingleAppsRTP::Video => "urn:xmpp:jingle:apps:rtp:video",
+            }
+            .to_owned()
+        }
+    }
+}
+
+mod identity {
+    use stanza::xep_0030::info;
+
+    pub struct Identity {
+        name: Option<String>,
+        category: Category,
+    }
+
+    impl From<info::Identity> for Identity {
+        fn from(value: info::Identity) -> Self {
+            let category = Category::from_category_and_type(&value.category, &value.r#type);
+            Self {
+                name: value.name,
+                category,
+            }
+        }
+    }
+
+    // TODO: separate crate for disco registry
+
+    /// categories taken from [XMPP Disco Categories](https://xmpp.org/registrar/disco-categories.html)
+    pub enum Category {
+        Account(Account),
+        Auth(Auth),
+        Authz(Authz),
+        Automation(Automation),
+        Client(Client),
+        Collaboration(Collaboration),
+        Component(Component),
+        Conference(Conference),
+        Directory(Directory),
+        Gateway(Gateway),
+        Headline(Headline),
+        Hierarchy(Hierarchy),
+        Proxy(Proxy),
+        PubSub(PubSub),
+        Server(Server),
+        Store(Store),
+        Other { category: String, r#type: String },
+    }
+
+    impl ToString for Category {
+        fn to_string(&self) -> String {
+            match self {
+                Category::Account(_account) => "account",
+                Category::Auth(_auth) => "auth",
+                Category::Authz(_authz) => "authz",
+                Category::Automation(_automation) => "automation",
+                Category::Client(_client) => "client",
+                Category::Collaboration(_collaboration) => "collaboration",
+                Category::Component(_component) => "component",
+                Category::Conference(_conference) => "conference",
+                Category::Directory(_directory) => "directory",
+                Category::Gateway(_gateway) => "gateway",
+                Category::Headline(_headline) => "headline",
+                Category::Hierarchy(_hierarchy) => "hierarchy",
+                Category::Proxy(_proxy) => "proxy",
+                Category::PubSub(_pub_sub) => "pubsub",
+                Category::Server(_server) => "server",
+                Category::Store(_store) => "store",
+                Category::Other {
+                    category,
+                    r#type: _,
+                } => category,
+            }
+            .to_owned()
+        }
+    }
+
+    impl Category {
+        pub fn from_category_and_type(category: &str, r#type: &str) -> Self {
+            match category {
+                "account" => Self::Account(r#type.into()),
+                "auth" => Self::Auth(r#type.into()),
+                "authz" => Self::Authz(r#type.into()),
+                "automation" => Self::Automation(r#type.into()),
+                "client" => Self::Client(r#type.into()),
+                "collaboration" => Self::Collaboration(r#type.into()),
+                "component" => Self::Component(r#type.into()),
+                "conference" => Self::Conference(r#type.into()),
+                "directory" => Self::Directory(r#type.into()),
+                "gateway" => Self::Gateway(r#type.into()),
+                "headline" => Self::Headline(r#type.into()),
+                "hierarchy" => Self::Hierarchy(r#type.into()),
+                "proxy" => Self::Proxy(r#type.into()),
+                "pubsub" => Self::PubSub(r#type.into()),
+                "server" => Self::Server(r#type.into()),
+                "store" => Self::Store(r#type.into()),
+                s => Self::Other {
+                    category: s.to_owned(),
+                    r#type: r#type.to_owned(),
+                },
+            }
+        }
+
+        pub fn r#type(&self) -> String {
+            match self {
+                Category::Account(account) => account.to_string(),
+                Category::Auth(auth) => auth.to_string(),
+                Category::Authz(authz) => authz.to_string(),
+                Category::Automation(automation) => automation.to_string(),
+                Category::Client(client) => client.to_string(),
+                Category::Collaboration(collaboration) => collaboration.to_string(),
+                Category::Component(component) => component.to_string(),
+                Category::Conference(conference) => conference.to_string(),
+                Category::Directory(directory) => directory.to_string(),
+                Category::Gateway(gateway) => gateway.to_string(),
+                Category::Headline(headline) => headline.to_string(),
+                Category::Hierarchy(hierarchy) => hierarchy.to_string(),
+                Category::Proxy(proxy) => proxy.to_string(),
+                Category::PubSub(pub_sub) => pub_sub.to_string(),
+                Category::Server(server) => server.to_string(),
+                Category::Store(store) => store.to_string(),
+                Category::Other {
+                    category: _,
+                    r#type,
+                } => r#type.to_owned(),
+            }
+        }
+    }
+
+    pub enum Account {
+        Admin,
+        Anonymous,
+        Registered,
+        Other(String),
+    }
+
+    impl ToString for Account {
+        fn to_string(&self) -> String {
+            match self {
+                Account::Admin => "admin",
+                Account::Anonymous => "anonymous",
+                Account::Registered => "registered",
+                Account::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Account {
+        fn from(value: &str) -> Self {
+            match value {
+                "admin" => Self::Admin,
+                "anonymous" => Self::Anonymous,
+                "registered" => Self::Registered,
+                s => Self::Other(s.to_string()),
+            }
+        }
+    }
+
+    pub enum Auth {
+        Cert,
+        Generic,
+        LDAP,
+        NTLM,
+        PAM,
+        Radius,
+        Other(String),
+    }
+
+    impl ToString for Auth {
+        fn to_string(&self) -> String {
+            match self {
+                Auth::Cert => "cert",
+                Auth::Generic => "generic",
+                Auth::LDAP => "ldap",
+                Auth::NTLM => "ntlm",
+                Auth::PAM => "pam",
+                Auth::Radius => "radius",
+                Auth::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Auth {
+        fn from(value: &str) -> Self {
+            match value {
+                "cert" => Self::Cert,
+                "generic" => Self::Generic,
+                "ldap" => Self::LDAP,
+                "ntlm" => Self::NTLM,
+                "pam" => Self::PAM,
+                "radius" => Self::Radius,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Authz {
+        Ephemeral,
+        Other(String),
+    }
+
+    impl ToString for Authz {
+        fn to_string(&self) -> String {
+            match self {
+                Authz::Ephemeral => "ephemeral",
+                Authz::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Authz {
+        fn from(value: &str) -> Self {
+            match value {
+                "ephemeral" => Self::Ephemeral,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Automation {
+        CommandList,
+        CommandNode,
+        RPC,
+        SOAP,
+        Translation,
+        Other(String),
+    }
+
+    impl ToString for Automation {
+        fn to_string(&self) -> String {
+            match self {
+                Automation::CommandList => "command-list",
+                Automation::CommandNode => "command-node",
+                Automation::RPC => "rpc",
+                Automation::SOAP => "soap",
+                Automation::Translation => "translation",
+                Automation::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Automation {
+        fn from(value: &str) -> Self {
+            match value {
+                "command-list" => Self::CommandList,
+                "command-node" => Self::CommandNode,
+                "rpc" => Self::RPC,
+                "soap" => Self::SOAP,
+                "translation" => Self::Translation,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Client {
+        Bot,
+        Console,
+        Game,
+        Handheld,
+        PC,
+        Phone,
+        SMS,
+        Tablet,
+        Web,
+        Other(String),
+    }
+
+    impl ToString for Client {
+        fn to_string(&self) -> String {
+            match self {
+                Client::Bot => "bot",
+                Client::Console => "console",
+                Client::Game => "game",
+                Client::Handheld => "handheld",
+                Client::PC => "pc",
+                Client::Phone => "phone",
+                Client::SMS => "sms",
+                Client::Tablet => "tablet",
+                Client::Web => "web",
+                Client::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Client {
+        fn from(value: &str) -> Self {
+            match value {
+                "bot" => Self::Bot,
+                "console" => Self::Console,
+                "game" => Self::Game,
+                "handheld" => Self::Handheld,
+                "pc" => Self::PC,
+                "phone" => Self::Phone,
+                "sms" => Self::SMS,
+                "tablet" => Self::Tablet,
+                "web" => Self::Web,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Collaboration {
+        Whiteboard,
+        Other(String),
+    }
+
+    impl ToString for Collaboration {
+        fn to_string(&self) -> String {
+            match self {
+                Collaboration::Whiteboard => "whiteboard",
+                Collaboration::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Collaboration {
+        fn from(value: &str) -> Self {
+            match value {
+                "whiteboard" => Self::Whiteboard,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Component {
+        Archive,
+        C2S,
+        Generic,
+        Load,
+        Log,
+        Presence,
+        Router,
+        S2S,
+        SM,
+        Stats,
+        Other(String),
+    }
+
+    impl ToString for Component {
+        fn to_string(&self) -> String {
+            match self {
+                Component::Archive => "archive",
+                Component::C2S => "c2s",
+                Component::Generic => "generic",
+                Component::Load => "load",
+                Component::Log => "log",
+                Component::Presence => "presence",
+                Component::Router => "router",
+                Component::S2S => "s2s",
+                Component::SM => "sm",
+                Component::Stats => "stats",
+                Component::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Component {
+        fn from(value: &str) -> Self {
+            match value {
+                "archive" => Self::Archive,
+                "c2s" => Self::C2S,
+                "generic" => Self::Generic,
+                "load" => Self::Load,
+                "log" => Self::Log,
+                "presence" => Self::Presence,
+                "router" => Self::Router,
+                "s2s" => Self::S2S,
+                "sm" => Self::SM,
+                "stats" => Self::Stats,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Conference {
+        IRC,
+        Text,
+        Other(String),
+    }
+
+    impl ToString for Conference {
+        fn to_string(&self) -> String {
+            match self {
+                Conference::IRC => "irc",
+                Conference::Text => "text",
+                Conference::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Conference {
+        fn from(value: &str) -> Self {
+            match value {
+                "irc" => Self::IRC,
+                "text" => Self::Text,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Directory {
+        Chatroom,
+        Group,
+        User,
+        WaitingList,
+        Other(String),
+    }
+
+    impl ToString for Directory {
+        fn to_string(&self) -> String {
+            match self {
+                Directory::Chatroom => "chatroom",
+                Directory::Group => "group",
+                Directory::User => "user",
+                Directory::WaitingList => "waiting-list",
+                Directory::Other(s) => s,
+            }
+            .to_string()
+        }
+    }
+
+    impl From<&str> for Directory {
+        fn from(value: &str) -> Self {
+            match value {
+                "chatroom" => Self::Chatroom,
+                "group" => Self::Group,
+                "user" => Self::User,
+                "waiting-list" => Self::WaitingList,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Gateway {
+        Aim,
+        Discord,
+        Facebook,
+        GaduGadu,
+        HttpWS,
+        ICQ,
+        IRC,
+        LCS,
+        Mattermost,
+        MRIM,
+        MSN,
+        MySpaceIM,
+        OCS,
+        PSTN,
+        QQ,
+        Sametime,
+        Signal,
+        SIMPLE,
+        Skype,
+        SMS,
+        SMTP,
+        Steam,
+        Telegram,
+        Tlen,
+        Xfire,
+        XMPP,
+        Yahoo,
+        Other(String),
+    }
+
+    impl ToString for Gateway {
+        fn to_string(&self) -> String {
+            match self {
+                Gateway::Aim => "aim",
+                Gateway::Discord => "discord",
+                Gateway::Facebook => "facebook",
+                Gateway::GaduGadu => "gadu-gadu",
+                Gateway::HttpWS => "http-ws",
+                Gateway::ICQ => "icq",
+                Gateway::IRC => "irc",
+                Gateway::LCS => "lcs",
+                Gateway::Mattermost => "mattermost",
+                Gateway::MRIM => "mrim",
+                Gateway::MSN => "msn",
+                Gateway::MySpaceIM => "myspaceim",
+                Gateway::OCS => "ocs",
+                Gateway::PSTN => "pstn",
+                Gateway::QQ => "qq",
+                Gateway::Sametime => "sametime",
+                Gateway::Signal => "signal",
+                Gateway::SIMPLE => "simple",
+                Gateway::Skype => "skype",
+                Gateway::SMS => "sms",
+                Gateway::SMTP => "smtp",
+                Gateway::Steam => "steam",
+                Gateway::Telegram => "telegram",
+                Gateway::Tlen => "tlen",
+                Gateway::Xfire => "xfire",
+                Gateway::XMPP => "xmpp",
+                Gateway::Yahoo => "yahoo",
+                Gateway::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Gateway {
+        fn from(value: &str) -> Self {
+            match value {
+                "aim" => Self::Aim,
+                "discord" => Self::Discord,
+                "facebook" => Self::Facebook,
+                "gadu-gadu" => Self::GaduGadu,
+                "http-ws" => Self::HttpWS,
+                "icq" => Self::ICQ,
+                "irc" => Self::IRC,
+                "lcs" => Self::LCS,
+                "mattermost" => Self::Mattermost,
+                "mrim" => Self::MRIM,
+                "msn" => Self::MSN,
+                "myspaceim" => Self::MySpaceIM,
+                "ocs" => Self::OCS,
+                "pstn" => Self::PSTN,
+                "qq" => Self::QQ,
+                "sametime" => Self::Sametime,
+                "signal" => Self::Signal,
+                "simple" => Self::SIMPLE,
+                "skype" => Self::Skype,
+                "sms" => Self::SMS,
+                "smtp" => Self::SMTP,
+                "steam" => Self::Steam,
+                "telegram" => Self::Telegram,
+                "tlen" => Self::Tlen,
+                "xfire" => Self::Xfire,
+                "xmpp" => Self::XMPP,
+                "yahoo" => Self::Yahoo,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Headline {
+        NewMail,
+        RSS,
+        Weather,
+        Other(String),
+    }
+
+    impl ToString for Headline {
+        fn to_string(&self) -> String {
+            match self {
+                Headline::NewMail => "new-mail",
+                Headline::RSS => "rss",
+                Headline::Weather => "weather",
+                Headline::Other(s) => s,
+            }
+            .to_string()
+        }
+    }
+
+    impl From<&str> for Headline {
+        fn from(value: &str) -> Self {
+            match value {
+                "new-mail" => Self::NewMail,
+                "rss" => Self::RSS,
+                "weather" => Self::Weather,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Hierarchy {
+        Branch,
+        Leaf,
+        Other(String),
+    }
+
+    impl ToString for Hierarchy {
+        fn to_string(&self) -> String {
+            match self {
+                Hierarchy::Branch => "branch",
+                Hierarchy::Leaf => "leaf",
+                Hierarchy::Other(s) => s,
+            }
+            .to_string()
+        }
+    }
+
+    impl From<&str> for Hierarchy {
+        fn from(value: &str) -> Self {
+            match value {
+                "branch" => Self::Branch,
+                "leaf" => Self::Leaf,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Proxy {
+        Bytestreams,
+        Other(String),
+    }
+
+    impl ToString for Proxy {
+        fn to_string(&self) -> String {
+            match self {
+                Proxy::Bytestreams => "bytestreams",
+                Proxy::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for Proxy {
+        fn from(value: &str) -> Self {
+            match value {
+                "bytestreams" => Self::Bytestreams,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum PubSub {
+        Collection,
+        Leaf,
+        PEP,
+        Service,
+        // TODO: should there be other in each of these
+        Other(String),
+    }
+
+    impl ToString for PubSub {
+        fn to_string(&self) -> String {
+            match self {
+                PubSub::Collection => "collection",
+                PubSub::Leaf => "leaf",
+                PubSub::PEP => "pep",
+                PubSub::Service => "service",
+                PubSub::Other(s) => s,
+            }
+            .to_owned()
+        }
+    }
+
+    impl From<&str> for PubSub {
+        fn from(value: &str) -> Self {
+            match value {
+                "collection" => Self::Collection,
+                "leaf" => Self::Leaf,
+                "pep" => Self::PEP,
+                "service" => Self::Service,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Server {
+        IM,
+        Other(String),
+    }
+
+    impl ToString for Server {
+        fn to_string(&self) -> String {
+            match self {
+                Server::IM => "im",
+                Server::Other(s) => s,
+            }
+            .to_string()
+        }
+    }
+
+    impl From<&str> for Server {
+        fn from(value: &str) -> Self {
+            match value {
+                "im" => Self::IM,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+
+    pub enum Store {
+        Berkeley,
+        File,
+        Generic,
+        LDAP,
+        MySQL,
+        Oracle,
+        Postgres,
+        Other(String),
+    }
+
+    impl ToString for Store {
+        fn to_string(&self) -> String {
+            match self {
+                Store::Berkeley => "berkeley",
+                Store::File => "file",
+                Store::Generic => "generic",
+                Store::LDAP => "ldap",
+                Store::MySQL => "mysql",
+                Store::Oracle => "oracle",
+                Store::Postgres => "postgres",
+                Store::Other(s) => s,
+            }
+            .to_string()
+        }
+    }
+
+    impl From<&str> for Store {
+        fn from(value: &str) -> Self {
+            match value {
+                "berkeley" => Self::Berkeley,
+                "file" => Self::File,
+                "generic" => Self::Generic,
+                "ldap" => Self::LDAP,
+                "mysql" => Self::MySQL,
+                "oracle" => Self::Oracle,
+                "postgres" => Self::Postgres,
+                s => Self::Other(s.to_owned()),
+            }
+        }
+    }
+}
diff --git a/filamento/src/lib.rs b/filamento/src/lib.rs
index 89da1a3..bc946ae 100644
--- a/filamento/src/lib.rs
+++ b/filamento/src/lib.rs
@@ -36,6 +36,7 @@ use uuid::Uuid;
 
 pub mod chat;
 pub mod db;
+pub mod disco;
 pub mod error;
 mod logic;
 pub mod presence;
@@ -97,6 +98,8 @@ pub enum Command {
     /// send a message to a jid (any kind of jid that can receive a message, e.g. a user or a
     /// chatroom). if disconnected, will be cached so when client connects, message will be sent.
     SendMessage(JID, Body, oneshot::Sender<Result<(), WriteError>>),
+    /// disco info request
+    DiscoInfo(JID, oneshot::Sender<Result>),
 }
 
 #[derive(Debug, Clone)]