initial commit

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "activitypub"
+version = "0.1.0"
+authors = ["asonix <asonix.dev@gmail.com>"]
+
+[dependencies]
+failure = "0.1"
+mime = "0.3"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"

src/activity/accept.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::AcceptType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Accept {
+    #[serde(rename = "type")]
+    kind: AcceptType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Accept {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Accept {}
+impl Object for Accept {}
+impl Activity for Accept {}

src/activity/add.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::AddType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Add {
+    #[serde(rename = "type")]
+    kind: AddType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Add {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Add {}
+impl Object for Add {}
+impl Activity for Add {}

src/activity/amove.rs

@@ -0,0 +1,89 @@
+use serde_json;
+
+use super::{kind::MoveType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AMove {
+    #[serde(rename = "type")]
+    kind: MoveType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    origin: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for AMove {}
+
+impl AMove {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin<O: Object>(&self) -> Result<O> {
+        self.get_item(|m| &m.origin)
+    }
+
+    pub fn origins<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|m| &m.origin)
+    }
+
+    pub fn origin_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|m| &m.origin)
+    }
+
+    pub fn origin_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|m| &m.origin)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|m| &m.target)
+    }
+}
+
+impl Base for AMove {}
+impl Object for AMove {}
+impl Activity for AMove {}

src/activity/announce.rs

@@ -0,0 +1,71 @@
+use serde_json;
+
+use super::{kind::AnnounceType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Announce {
+    #[serde(rename = "type")]
+    kind: AnnounceType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Announce {}
+
+impl Announce {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|m| &m.target)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|m| &m.target)
+    }
+}
+
+impl Base for Announce {}
+impl Object for Announce {}
+impl Activity for Announce {}

src/activity/arrive.rs

@@ -0,0 +1,76 @@
+use serde_json;
+
+use super::{kind::ArriveType, properties::ActivityProperties, Activity, IntransitiveActivity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Arrive {
+    #[serde(rename = "type")]
+    kind: ArriveType,
+    actor: serde_json::Value,
+    location: serde_json::Value,
+    origin: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Arrive {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn location<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.location.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn locations<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.location.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn location_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.location.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn location_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.location.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.origin.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origins<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.origin.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.origin.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.origin.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Arrive {}
+impl Object for Arrive {}
+impl Activity for Arrive {}
+impl IntransitiveActivity for Arrive {}

src/activity/block.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::BlockType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Block {
+    #[serde(rename = "type")]
+    kind: BlockType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Block {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Block {}
+impl Object for Block {}
+impl Activity for Block {}

src/activity/create.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::CreateType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Create {
+    #[serde(rename = "type")]
+    kind: CreateType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Create {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Create {}
+impl Object for Create {}
+impl Activity for Create {}

src/activity/delete.rs

@@ -0,0 +1,71 @@
+use serde_json;
+
+use super::{kind::DeleteType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Delete {
+    #[serde(rename = "type")]
+    kind: DeleteType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    origin: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Delete {}
+
+impl Delete {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origins<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.origin)
+    }
+}
+
+impl Base for Delete {}
+impl Object for Delete {}
+impl Activity for Delete {}

src/activity/dislike.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::DislikeType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Dislike {
+    #[serde(rename = "type")]
+    kind: DislikeType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Dislike {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Dislike {}
+impl Object for Dislike {}
+impl Activity for Dislike {}

src/activity/flag.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::FlagType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Flag {
+    #[serde(rename = "type")]
+    kind: FlagType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Flag {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Flag {}
+impl Object for Flag {}
+impl Activity for Flag {}

src/activity/follow.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::FollowType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Follow {
+    #[serde(rename = "type")]
+    kind: FollowType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Follow {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Follow {}
+impl Object for Follow {}
+impl Activity for Follow {}

src/activity/ignore.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::IgnoreType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Ignore {
+    #[serde(rename = "type")]
+    kind: IgnoreType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Ignore {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Ignore {}
+impl Object for Ignore {}
+impl Activity for Ignore {}

src/activity/invite.rs

@@ -0,0 +1,67 @@
+use serde_json;
+
+use super::{kind::InviteType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Invite {
+    #[serde(rename = "type")]
+    kind: InviteType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    target: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Invite {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.target.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.target.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.target.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.target.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Invite {}
+impl Object for Invite {}
+impl Activity for Invite {}

src/activity/join.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::JoinType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Join {
+    #[serde(rename = "type")]
+    kind: JoinType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Join {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Join {}
+impl Object for Join {}
+impl Activity for Join {}

src/activity/kind/accept.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct AcceptType;
+
+impl Serialize for AcceptType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Accept")
+    }
+}
+
+pub struct AcceptTypeVisitor;
+
+impl<'de> Visitor<'de> for AcceptTypeVisitor {
+    type Value = AcceptType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Accept'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Accept" {
+            Ok(AcceptType)
+        } else {
+            Err(de::Error::custom("Type not Accept"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AcceptType {
+    fn deserialize<D>(deserializer: D) -> Result<AcceptType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AcceptTypeVisitor)
+    }
+}

src/activity/kind/add.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct AddType;
+
+impl Serialize for AddType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Add")
+    }
+}
+
+pub struct AddTypeVisitor;
+
+impl<'de> Visitor<'de> for AddTypeVisitor {
+    type Value = AddType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Add'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Add" {
+            Ok(AddType)
+        } else {
+            Err(de::Error::custom("Type not create"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AddType {
+    fn deserialize<D>(deserializer: D) -> Result<AddType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AddTypeVisitor)
+    }
+}

src/activity/kind/amove.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct MoveType;
+
+impl Serialize for MoveType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Move")
+    }
+}
+
+pub struct MoveTypeVisitor;
+
+impl<'de> Visitor<'de> for MoveTypeVisitor {
+    type Value = MoveType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Move'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Move" {
+            Ok(MoveType)
+        } else {
+            Err(de::Error::custom("Type not Move"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MoveType {
+    fn deserialize<D>(deserializer: D) -> Result<MoveType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(MoveTypeVisitor)
+    }
+}

src/activity/kind/announce.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct AnnounceType;
+
+impl Serialize for AnnounceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Announce")
+    }
+}
+
+pub struct AnnounceTypeVisitor;
+
+impl<'de> Visitor<'de> for AnnounceTypeVisitor {
+    type Value = AnnounceType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Announce'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Announce" {
+            Ok(AnnounceType)
+        } else {
+            Err(de::Error::custom("Type not Announce"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AnnounceType {
+    fn deserialize<D>(deserializer: D) -> Result<AnnounceType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AnnounceTypeVisitor)
+    }
+}

src/activity/kind/arrive.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ArriveType;
+
+impl Serialize for ArriveType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Arrive")
+    }
+}
+
+pub struct ArriveTypeVisitor;
+
+impl<'de> Visitor<'de> for ArriveTypeVisitor {
+    type Value = ArriveType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Arrive'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Arrive" {
+            Ok(ArriveType)
+        } else {
+            Err(de::Error::custom("Type not Arrive"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ArriveType {
+    fn deserialize<D>(deserializer: D) -> Result<ArriveType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ArriveTypeVisitor)
+    }
+}

src/activity/kind/block.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct BlockType;
+
+impl Serialize for BlockType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Block")
+    }
+}
+
+pub struct BlockTypeVisitor;
+
+impl<'de> Visitor<'de> for BlockTypeVisitor {
+    type Value = BlockType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Block'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Block" {
+            Ok(BlockType)
+        } else {
+            Err(de::Error::custom("Type not Block"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for BlockType {
+    fn deserialize<D>(deserializer: D) -> Result<BlockType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(BlockTypeVisitor)
+    }
+}

src/activity/kind/create.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct CreateType;
+
+impl Serialize for CreateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Create")
+    }
+}
+
+pub struct CreateTypeVisitor;
+
+impl<'de> Visitor<'de> for CreateTypeVisitor {
+    type Value = CreateType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Create'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Create" {
+            Ok(CreateType)
+        } else {
+            Err(de::Error::custom("Type not create"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CreateType {
+    fn deserialize<D>(deserializer: D) -> Result<CreateType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(CreateTypeVisitor)
+    }
+}

src/activity/kind/delete.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct DeleteType;
+
+impl Serialize for DeleteType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Delete")
+    }
+}
+
+pub struct DeleteTypeVisitor;
+
+impl<'de> Visitor<'de> for DeleteTypeVisitor {
+    type Value = DeleteType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Delete'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Delete" {
+            Ok(DeleteType)
+        } else {
+            Err(de::Error::custom("Type not Delete"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DeleteType {
+    fn deserialize<D>(deserializer: D) -> Result<DeleteType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(DeleteTypeVisitor)
+    }
+}

src/activity/kind/dislike.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct DislikeType;
+
+impl Serialize for DislikeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Dislike")
+    }
+}
+
+pub struct DislikeTypeVisitor;
+
+impl<'de> Visitor<'de> for DislikeTypeVisitor {
+    type Value = DislikeType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Dislike'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Dislike" {
+            Ok(DislikeType)
+        } else {
+            Err(de::Error::custom("Type not Dislike"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DislikeType {
+    fn deserialize<D>(deserializer: D) -> Result<DislikeType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(DislikeTypeVisitor)
+    }
+}

src/activity/kind/flag.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct FlagType;
+
+impl Serialize for FlagType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Flag")
+    }
+}
+
+pub struct FlagTypeVisitor;
+
+impl<'de> Visitor<'de> for FlagTypeVisitor {
+    type Value = FlagType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Flag'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Flag" {
+            Ok(FlagType)
+        } else {
+            Err(de::Error::custom("Type not Flag"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FlagType {
+    fn deserialize<D>(deserializer: D) -> Result<FlagType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(FlagTypeVisitor)
+    }
+}

src/activity/kind/follow.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct FollowType;
+
+impl Serialize for FollowType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Follow")
+    }
+}
+
+pub struct FollowTypeVisitor;
+
+impl<'de> Visitor<'de> for FollowTypeVisitor {
+    type Value = FollowType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Follow'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Follow" {
+            Ok(FollowType)
+        } else {
+            Err(de::Error::custom("Type not Follow"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FollowType {
+    fn deserialize<D>(deserializer: D) -> Result<FollowType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(FollowTypeVisitor)
+    }
+}

src/activity/kind/ignore.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct IgnoreType;
+
+impl Serialize for IgnoreType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Ignore")
+    }
+}
+
+pub struct IgnoreTypeVisitor;
+
+impl<'de> Visitor<'de> for IgnoreTypeVisitor {
+    type Value = IgnoreType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Ignore'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Ignore" {
+            Ok(IgnoreType)
+        } else {
+            Err(de::Error::custom("Type not Ignore"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IgnoreType {
+    fn deserialize<D>(deserializer: D) -> Result<IgnoreType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(IgnoreTypeVisitor)
+    }
+}

src/activity/kind/invite.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct InviteType;
+
+impl Serialize for InviteType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Invite")
+    }
+}
+
+pub struct InviteTypeVisitor;
+
+impl<'de> Visitor<'de> for InviteTypeVisitor {
+    type Value = InviteType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Invite'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Invite" {
+            Ok(InviteType)
+        } else {
+            Err(de::Error::custom("Type not Invite"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for InviteType {
+    fn deserialize<D>(deserializer: D) -> Result<InviteType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(InviteTypeVisitor)
+    }
+}

src/activity/kind/join.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct JoinType;
+
+impl Serialize for JoinType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Join")
+    }
+}
+
+pub struct JoinTypeVisitor;
+
+impl<'de> Visitor<'de> for JoinTypeVisitor {
+    type Value = JoinType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Join'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Join" {
+            Ok(JoinType)
+        } else {
+            Err(de::Error::custom("Type not Join"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for JoinType {
+    fn deserialize<D>(deserializer: D) -> Result<JoinType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(JoinTypeVisitor)
+    }
+}

src/activity/kind/leave.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct LeaveType;
+
+impl Serialize for LeaveType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Leave")
+    }
+}
+
+pub struct LeaveTypeVisitor;
+
+impl<'de> Visitor<'de> for LeaveTypeVisitor {
+    type Value = LeaveType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Leave'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Leave" {
+            Ok(LeaveType)
+        } else {
+            Err(de::Error::custom("Type not Leave"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LeaveType {
+    fn deserialize<D>(deserializer: D) -> Result<LeaveType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(LeaveTypeVisitor)
+    }
+}

src/activity/kind/like.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct LikeType;
+
+impl Serialize for LikeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Like")
+    }
+}
+
+pub struct LikeTypeVisitor;
+
+impl<'de> Visitor<'de> for LikeTypeVisitor {
+    type Value = LikeType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Like'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Like" {
+            Ok(LikeType)
+        } else {
+            Err(de::Error::custom("Type not Like"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LikeType {
+    fn deserialize<D>(deserializer: D) -> Result<LikeType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(LikeTypeVisitor)
+    }
+}

src/activity/kind/listen.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ListenType;
+
+impl Serialize for ListenType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Listen")
+    }
+}
+
+pub struct ListenTypeVisitor;
+
+impl<'de> Visitor<'de> for ListenTypeVisitor {
+    type Value = ListenType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Listen'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Listen" {
+            Ok(ListenType)
+        } else {
+            Err(de::Error::custom("Type not Listen"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListenType {
+    fn deserialize<D>(deserializer: D) -> Result<ListenType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ListenTypeVisitor)
+    }
+}

src/activity/kind/mod.rs

@@ -0,0 +1,57 @@
+mod accept;
+mod add;
+mod amove;
+mod announce;
+mod arrive;
+mod block;
+mod create;
+mod delete;
+mod dislike;
+mod flag;
+mod follow;
+mod ignore;
+mod invite;
+mod join;
+mod leave;
+mod like;
+mod listen;
+mod offer;
+mod question;
+mod read;
+mod reject;
+mod remove;
+mod tentative_accept;
+mod tentative_reject;
+mod travel;
+mod undo;
+mod update;
+mod view;
+
+pub use self::accept::*;
+pub use self::add::*;
+pub use self::amove::*;
+pub use self::announce::*;
+pub use self::arrive::*;
+pub use self::block::*;
+pub use self::create::*;
+pub use self::delete::*;
+pub use self::dislike::*;
+pub use self::flag::*;
+pub use self::follow::*;
+pub use self::ignore::*;
+pub use self::invite::*;
+pub use self::join::*;
+pub use self::leave::*;
+pub use self::like::*;
+pub use self::listen::*;
+pub use self::offer::*;
+pub use self::question::*;
+pub use self::read::*;
+pub use self::reject::*;
+pub use self::remove::*;
+pub use self::tentative_accept::*;
+pub use self::tentative_reject::*;
+pub use self::travel::*;
+pub use self::undo::*;
+pub use self::update::*;
+pub use self::view::*;

src/activity/kind/offer.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct OfferType;
+
+impl Serialize for OfferType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Offer")
+    }
+}
+
+pub struct OfferTypeVisitor;
+
+impl<'de> Visitor<'de> for OfferTypeVisitor {
+    type Value = OfferType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Offer'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Offer" {
+            Ok(OfferType)
+        } else {
+            Err(de::Error::custom("Type not Offer"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OfferType {
+    fn deserialize<D>(deserializer: D) -> Result<OfferType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(OfferTypeVisitor)
+    }
+}

src/activity/kind/question.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct QuestionType;
+
+impl Serialize for QuestionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Question")
+    }
+}
+
+pub struct QuestionTypeVisitor;
+
+impl<'de> Visitor<'de> for QuestionTypeVisitor {
+    type Value = QuestionType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Question'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Question" {
+            Ok(QuestionType)
+        } else {
+            Err(de::Error::custom("Type not Question"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for QuestionType {
+    fn deserialize<D>(deserializer: D) -> Result<QuestionType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(QuestionTypeVisitor)
+    }
+}

src/activity/kind/read.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ReadType;
+
+impl Serialize for ReadType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Read")
+    }
+}
+
+pub struct ReadTypeVisitor;
+
+impl<'de> Visitor<'de> for ReadTypeVisitor {
+    type Value = ReadType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Read'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Read" {
+            Ok(ReadType)
+        } else {
+            Err(de::Error::custom("Type not Read"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ReadType {
+    fn deserialize<D>(deserializer: D) -> Result<ReadType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ReadTypeVisitor)
+    }
+}

src/activity/kind/reject.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct RejectType;
+
+impl Serialize for RejectType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Reject")
+    }
+}
+
+pub struct RejectTypeVisitor;
+
+impl<'de> Visitor<'de> for RejectTypeVisitor {
+    type Value = RejectType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Reject'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Reject" {
+            Ok(RejectType)
+        } else {
+            Err(de::Error::custom("Type not Reject"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RejectType {
+    fn deserialize<D>(deserializer: D) -> Result<RejectType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(RejectTypeVisitor)
+    }
+}

src/activity/kind/remove.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct RemoveType;
+
+impl Serialize for RemoveType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Remove")
+    }
+}
+
+pub struct RemoveTypeVisitor;
+
+impl<'de> Visitor<'de> for RemoveTypeVisitor {
+    type Value = RemoveType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Remove'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Remove" {
+            Ok(RemoveType)
+        } else {
+            Err(de::Error::custom("Type not Remove"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RemoveType {
+    fn deserialize<D>(deserializer: D) -> Result<RemoveType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(RemoveTypeVisitor)
+    }
+}

src/activity/kind/tentative_accept.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct TentativeAcceptType;
+
+impl Serialize for TentativeAcceptType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("TentativeAccept")
+    }
+}
+
+pub struct TentativeAcceptTypeVisitor;
+
+impl<'de> Visitor<'de> for TentativeAcceptTypeVisitor {
+    type Value = TentativeAcceptType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'TentativeAccept'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "TentativeAccept" {
+            Ok(TentativeAcceptType)
+        } else {
+            Err(de::Error::custom("Type not TentativeAccept"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TentativeAcceptType {
+    fn deserialize<D>(deserializer: D) -> Result<TentativeAcceptType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(TentativeAcceptTypeVisitor)
+    }
+}

src/activity/kind/tentative_reject.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct TentativeRejectType;
+
+impl Serialize for TentativeRejectType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("TentativeReject")
+    }
+}
+
+pub struct TentativeRejectTypeVisitor;
+
+impl<'de> Visitor<'de> for TentativeRejectTypeVisitor {
+    type Value = TentativeRejectType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'TentativeReject'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "TentativeReject" {
+            Ok(TentativeRejectType)
+        } else {
+            Err(de::Error::custom("Type not TentativeReject"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TentativeRejectType {
+    fn deserialize<D>(deserializer: D) -> Result<TentativeRejectType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(TentativeRejectTypeVisitor)
+    }
+}

src/activity/kind/travel.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct TravelType;
+
+impl Serialize for TravelType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Travel")
+    }
+}
+
+pub struct TravelTypeVisitor;
+
+impl<'de> Visitor<'de> for TravelTypeVisitor {
+    type Value = TravelType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Travel'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Travel" {
+            Ok(TravelType)
+        } else {
+            Err(de::Error::custom("Type not Travel"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TravelType {
+    fn deserialize<D>(deserializer: D) -> Result<TravelType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(TravelTypeVisitor)
+    }
+}

src/activity/kind/undo.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct UndoType;
+
+impl Serialize for UndoType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Undo")
+    }
+}
+
+pub struct UndoTypeVisitor;
+
+impl<'de> Visitor<'de> for UndoTypeVisitor {
+    type Value = UndoType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Undo'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Undo" {
+            Ok(UndoType)
+        } else {
+            Err(de::Error::custom("Type not Undo"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UndoType {
+    fn deserialize<D>(deserializer: D) -> Result<UndoType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(UndoTypeVisitor)
+    }
+}

src/activity/kind/update.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct UpdateType;
+
+impl Serialize for UpdateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Update")
+    }
+}
+
+pub struct UpdateTypeVisitor;
+
+impl<'de> Visitor<'de> for UpdateTypeVisitor {
+    type Value = UpdateType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Update'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Update" {
+            Ok(UpdateType)
+        } else {
+            Err(de::Error::custom("Type not update"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UpdateType {
+    fn deserialize<D>(deserializer: D) -> Result<UpdateType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(UpdateTypeVisitor)
+    }
+}

src/activity/kind/view.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ViewType;
+
+impl Serialize for ViewType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("View")
+    }
+}
+
+pub struct ViewTypeVisitor;
+
+impl<'de> Visitor<'de> for ViewTypeVisitor {
+    type Value = ViewType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'View'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "View" {
+            Ok(ViewType)
+        } else {
+            Err(de::Error::custom("Type not View"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ViewType {
+    fn deserialize<D>(deserializer: D) -> Result<ViewType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ViewTypeVisitor)
+    }
+}

src/activity/leave.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::LeaveType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Leave {
+    #[serde(rename = "type")]
+    kind: LeaveType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Leave {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Leave {}
+impl Object for Leave {}
+impl Activity for Leave {}

src/activity/like.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::LikeType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Like {
+    #[serde(rename = "type")]
+    kind: LikeType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Like {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Like {}
+impl Object for Like {}
+impl Activity for Like {}

src/activity/listen.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::ListenType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Listen {
+    #[serde(rename = "type")]
+    kind: ListenType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Listen {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Listen {}
+impl Object for Listen {}
+impl Activity for Listen {}

src/activity/mod.rs

@@ -0,0 +1,65 @@
+use object::Object;
+
+mod accept;
+mod add;
+mod amove;
+mod announce;
+mod arrive;
+mod block;
+mod create;
+mod delete;
+mod dislike;
+mod flag;
+mod follow;
+mod ignore;
+mod invite;
+mod join;
+mod kind;
+mod leave;
+mod like;
+mod listen;
+mod offer;
+mod properties;
+mod question;
+mod read;
+mod reject;
+mod remove;
+mod tentative_accept;
+mod tentative_reject;
+mod travel;
+mod undo;
+mod update;
+mod view;
+pub use self::accept::*;
+pub use self::add::*;
+pub use self::amove::*;
+pub use self::announce::*;
+pub use self::arrive::*;
+pub use self::block::*;
+pub use self::create::*;
+pub use self::delete::*;
+pub use self::dislike::*;
+pub use self::flag::*;
+pub use self::follow::*;
+pub use self::ignore::*;
+pub use self::invite::*;
+pub use self::join::*;
+pub use self::kind::*;
+pub use self::leave::*;
+pub use self::like::*;
+pub use self::listen::*;
+pub use self::offer::*;
+pub use self::properties::*;
+pub use self::question::*;
+pub use self::read::*;
+pub use self::reject::*;
+pub use self::remove::*;
+pub use self::tentative_accept::*;
+pub use self::tentative_reject::*;
+pub use self::travel::*;
+pub use self::undo::*;
+pub use self::update::*;
+pub use self::view::*;
+
+pub trait Activity: Object {}
+pub trait IntransitiveActivity: Activity {}

src/activity/offer.rs

@@ -0,0 +1,71 @@
+use serde_json;
+
+use super::{kind::OfferType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Offer {
+    #[serde(rename = "type")]
+    kind: OfferType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Offer {}
+
+impl Offer {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.target)
+    }
+}
+
+impl Base for Offer {}
+impl Object for Offer {}
+impl Activity for Offer {}

src/activity/properties.rs

@@ -0,0 +1,51 @@
+use serde_json;
+
+use error::Result;
+use link::Link;
+use object::Object;
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActivityProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    result: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    instrument: Option<serde_json::Value>,
+}
+
+impl Properties for ActivityProperties {}
+
+impl ActivityProperties {
+    pub fn result<O: Object>(&self) -> Result<O> {
+        self.get_item(|ap| &ap.result)
+    }
+
+    pub fn results<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|ap| &ap.result)
+    }
+
+    pub fn result_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|ap| &ap.result)
+    }
+
+    pub fn result_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|ap| &ap.result)
+    }
+
+    pub fn instrument<O: Object>(&self) -> Result<O> {
+        self.get_item(|ap| &ap.instrument)
+    }
+
+    pub fn instruments<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|ap| &ap.instrument)
+    }
+
+    pub fn instrument_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|ap| &ap.instrument)
+    }
+
+    pub fn instrument_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|ap| &ap.instrument)
+    }
+}

src/activity/question.rs

@@ -0,0 +1,67 @@
+use serde::de::DeserializeOwned;
+use serde_json;
+
+use super::{kind::QuestionType, properties::ActivityProperties, Activity, IntransitiveActivity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Question {
+    #[serde(rename = "type")]
+    kind: QuestionType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    one_of: Option<Vec<serde_json::Value>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    any_of: Option<Vec<serde_json::Value>>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Question {}
+
+impl Question {
+    pub fn one_of<O: Object>(&self) -> Result<Vec<O>> {
+        vec_item(&self.one_of)
+    }
+
+    pub fn one_of_link<L: Link>(&self) -> Result<Vec<L>> {
+        vec_item(&self.one_of)
+    }
+
+    pub fn any_of<O: Object>(&self) -> Result<Vec<O>> {
+        vec_item(&self.any_of)
+    }
+
+    pub fn any_of_link<L: Link>(&self) -> Result<Vec<L>> {
+        vec_item(&self.any_of)
+    }
+}
+fn vec_item<D: DeserializeOwned>(v: &Option<Vec<serde_json::Value>>) -> Result<Vec<D>> {
+    if let Some(v) = v.clone() {
+        v.into_iter()
+            .map(|value| serde_json::from_value(value))
+            .fold(Ok(Vec::new()), |acc, item| match acc {
+                Ok(mut v) => match item {
+                    Ok(item) => {
+                        v.push(item);
+                        Ok(v)
+                    }
+                    Err(_) => Err(Error::Deserialize),
+                },
+                Err(e) => Err(e),
+            })
+    } else {
+        Err(Error::NotFound)
+    }
+}
+
+impl Base for Question {}
+impl Object for Question {}
+impl Activity for Question {}
+impl IntransitiveActivity for Question {}

src/activity/read.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::ReadType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Read {
+    #[serde(rename = "type")]
+    kind: ReadType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Read {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Read {}
+impl Object for Read {}
+impl Activity for Read {}

src/activity/reject.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::RejectType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Reject {
+    #[serde(rename = "type")]
+    kind: RejectType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Reject {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Reject {}
+impl Object for Reject {}
+impl Activity for Reject {}

src/activity/remove.rs

@@ -0,0 +1,89 @@
+use serde_json;
+
+use super::{kind::RemoveType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Remove {
+    #[serde(rename = "type")]
+    kind: RemoveType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    origin: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Remove {}
+
+impl Remove {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origins<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.target)
+    }
+}
+
+impl Base for Remove {}
+impl Object for Remove {}
+impl Activity for Remove {}

src/activity/tentative_accept.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::TentativeAcceptType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TentativeAccept {
+    #[serde(rename = "type")]
+    kind: TentativeAcceptType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl TentativeAccept {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for TentativeAccept {}
+impl Object for TentativeAccept {}
+impl Activity for TentativeAccept {}

src/activity/tentative_reject.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::TentativeRejectType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TentativeReject {
+    #[serde(rename = "type")]
+    kind: TentativeRejectType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl TentativeReject {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for TentativeReject {}
+impl Object for TentativeReject {}
+impl Activity for TentativeReject {}

src/activity/travel.rs

@@ -0,0 +1,81 @@
+use serde_json;
+
+use super::{kind::TravelType, properties::ActivityProperties, Activity, IntransitiveActivity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Travel {
+    #[serde(rename = "type")]
+    kind: TravelType,
+    actor: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    origin: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<serde_json::Value>,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Properties for Travel {}
+
+impl Travel {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn origin<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origins<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn origin_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.origin)
+    }
+
+    pub fn target<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn targets<O: Object>(&self) -> Result<O> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|d| &d.target)
+    }
+
+    pub fn target_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|d| &d.target)
+    }
+}
+
+impl Base for Travel {}
+impl Object for Travel {}
+impl Activity for Travel {}
+impl IntransitiveActivity for Travel {}

src/activity/undo.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::UndoType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Undo {
+    #[serde(rename = "type")]
+    kind: UndoType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Undo {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Undo {}
+impl Object for Undo {}
+impl Activity for Undo {}

src/activity/update.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::UpdateType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Update {
+    #[serde(rename = "type")]
+    kind: UpdateType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl Update {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Update {}
+impl Object for Update {}
+impl Activity for Update {}

src/activity/view.rs

@@ -0,0 +1,50 @@
+use serde_json;
+
+use super::{kind::ViewType, properties::ActivityProperties, Activity};
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+use object::{Object, ObjectProperties};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct View {
+    #[serde(rename = "type")]
+    kind: ViewType,
+    actor: serde_json::Value,
+    object: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub activity_props: ActivityProperties,
+}
+
+impl View {
+    pub fn actor<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actors<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn actor_links<L: Link>(&self) -> Result<Vec<L>> {
+        serde_json::from_value(self.actor.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn objects<O: Object>(&self) -> Result<Vec<O>> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for View {}
+impl Object for View {}
+impl Activity for View {}

src/actor/kind/application.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ApplicationType;
+
+impl Serialize for ApplicationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Application")
+    }
+}
+
+pub struct ApplicationTypeVisitor;
+
+impl<'de> Visitor<'de> for ApplicationTypeVisitor {
+    type Value = ApplicationType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Application'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Application" {
+            Ok(ApplicationType)
+        } else {
+            Err(de::Error::custom("Type not Application"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ApplicationType {
+    fn deserialize<D>(deserializer: D) -> Result<ApplicationType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ApplicationTypeVisitor)
+    }
+}

src/actor/kind/group.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct GroupType;
+
+impl Serialize for GroupType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Group")
+    }
+}
+
+pub struct GroupTypeVisitor;
+
+impl<'de> Visitor<'de> for GroupTypeVisitor {
+    type Value = GroupType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Group'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Group" {
+            Ok(GroupType)
+        } else {
+            Err(de::Error::custom("Type not Group"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GroupType {
+    fn deserialize<D>(deserializer: D) -> Result<GroupType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(GroupTypeVisitor)
+    }
+}

src/actor/kind/mod.rs

@@ -0,0 +1,11 @@
+mod application;
+mod group;
+mod organization;
+mod person;
+mod service;
+
+pub use self::application::*;
+pub use self::group::*;
+pub use self::organization::*;
+pub use self::person::*;
+pub use self::service::*;

src/actor/kind/organization.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct OrganizationType;
+
+impl Serialize for OrganizationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Organization")
+    }
+}
+
+pub struct OrganizationTypeVisitor;
+
+impl<'de> Visitor<'de> for OrganizationTypeVisitor {
+    type Value = OrganizationType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Organization'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Organization" {
+            Ok(OrganizationType)
+        } else {
+            Err(de::Error::custom("Type not Organization"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OrganizationType {
+    fn deserialize<D>(deserializer: D) -> Result<OrganizationType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(OrganizationTypeVisitor)
+    }
+}

src/actor/kind/person.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct PersonType;
+
+impl Serialize for PersonType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Person")
+    }
+}
+
+pub struct PersonTypeVisitor;
+
+impl<'de> Visitor<'de> for PersonTypeVisitor {
+    type Value = PersonType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Person'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Person" {
+            Ok(PersonType)
+        } else {
+            Err(de::Error::custom("Type not Person"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for PersonType {
+    fn deserialize<D>(deserializer: D) -> Result<PersonType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(PersonTypeVisitor)
+    }
+}

src/actor/kind/service.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ServiceType;
+
+impl Serialize for ServiceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Service")
+    }
+}
+
+pub struct ServiceTypeVisitor;
+
+impl<'de> Visitor<'de> for ServiceTypeVisitor {
+    type Value = ServiceType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Service'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Service" {
+            Ok(ServiceType)
+        } else {
+            Err(de::Error::custom("Type not Service"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceType {
+    fn deserialize<D>(deserializer: D) -> Result<ServiceType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ServiceTypeVisitor)
+    }
+}

src/actor/mod.rs

@@ -0,0 +1,67 @@
+use base::Base;
+use object::{Object, ObjectProperties};
+
+mod kind;
+pub use self::kind::*;
+
+pub trait Actor: Object {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Appliation {
+    #[serde(rename = "type")]
+    kind: ApplicationType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Appliation {}
+impl Object for Appliation {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Group {
+    #[serde(rename = "type")]
+    kind: GroupType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Group {}
+impl Object for Group {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Organization {
+    #[serde(rename = "type")]
+    kind: OrganizationType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Organization {}
+impl Object for Organization {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Person {
+    #[serde(rename = "type")]
+    kind: PersonType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Person {}
+impl Object for Person {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Service {
+    #[serde(rename = "type")]
+    kind: ServiceType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Service {}
+impl Object for Service {}

src/base.rs

@@ -0,0 +1,3 @@
+use serde::{de::DeserializeOwned, ser::Serialize};
+
+pub trait Base: Serialize + DeserializeOwned {}

src/collection/kind/collection.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct CollectionType;
+
+impl Serialize for CollectionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Collection")
+    }
+}
+
+pub struct CollectionTypeVisitor;
+
+impl<'de> Visitor<'de> for CollectionTypeVisitor {
+    type Value = CollectionType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Collection'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Collection" {
+            Ok(CollectionType)
+        } else {
+            Err(de::Error::custom("Type not Collection"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CollectionType {
+    fn deserialize<D>(deserializer: D) -> Result<CollectionType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(CollectionTypeVisitor)
+    }
+}

src/collection/kind/collection_page.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct CollectionPageType;
+
+impl Serialize for CollectionPageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("CollectionPage")
+    }
+}
+
+pub struct CollectionPageTypeVisitor;
+
+impl<'de> Visitor<'de> for CollectionPageTypeVisitor {
+    type Value = CollectionPageType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'CollectionPage'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "CollectionPage" {
+            Ok(CollectionPageType)
+        } else {
+            Err(de::Error::custom("Type not CollectionPage"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CollectionPageType {
+    fn deserialize<D>(deserializer: D) -> Result<CollectionPageType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(CollectionPageTypeVisitor)
+    }
+}

src/collection/kind/mod.rs

@@ -0,0 +1,9 @@
+mod collection;
+mod collection_page;
+mod ordered_collection;
+mod ordered_collection_page;
+
+pub use self::collection::*;
+pub use self::collection_page::*;
+pub use self::ordered_collection::*;
+pub use self::ordered_collection_page::*;

src/collection/kind/ordered_collection.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct OrderedCollectionType;
+
+impl Serialize for OrderedCollectionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("OrderedCollection")
+    }
+}
+
+pub struct OrderedCollectionTypeVisitor;
+
+impl<'de> Visitor<'de> for OrderedCollectionTypeVisitor {
+    type Value = OrderedCollectionType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'OrderedCollection'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "OrderedCollection" {
+            Ok(OrderedCollectionType)
+        } else {
+            Err(de::Error::custom("Type not OrderedCollection"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OrderedCollectionType {
+    fn deserialize<D>(deserializer: D) -> Result<OrderedCollectionType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(OrderedCollectionTypeVisitor)
+    }
+}

src/collection/kind/ordered_collection_page.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct OrderedCollectionPageType;
+
+impl Serialize for OrderedCollectionPageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("OrderedCollectionPage")
+    }
+}
+
+pub struct OrderedCollectionPageTypeVisitor;
+
+impl<'de> Visitor<'de> for OrderedCollectionPageTypeVisitor {
+    type Value = OrderedCollectionPageType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'OrderedCollectionPage'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "OrderedCollectionPage" {
+            Ok(OrderedCollectionPageType)
+        } else {
+            Err(de::Error::custom("Type not OrderedCollectionPage"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OrderedCollectionPageType {
+    fn deserialize<D>(deserializer: D) -> Result<OrderedCollectionPageType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(OrderedCollectionPageTypeVisitor)
+    }
+}

src/collection/mod.rs

@@ -0,0 +1,75 @@
+use serde_json;
+
+use base::Base;
+use object::Object;
+
+mod kind;
+mod properties;
+pub use self::kind::*;
+pub use self::properties::*;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Collection {
+    #[serde(rename = "@context")]
+    context: serde_json::Value,
+    #[serde(rename = "type")]
+    kind: CollectionType,
+    items: Vec<serde_json::Value>,
+    #[serde(flatten)]
+    pub collection_props: CollectionProperties,
+}
+
+impl Base for Collection {}
+impl Object for Collection {}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollection {
+    #[serde(rename = "@context")]
+    context: serde_json::Value,
+    #[serde(rename = "type")]
+    kind: OrderedCollectionType,
+    items: Vec<serde_json::Value>,
+    #[serde(flatten)]
+    pub collection_props: CollectionProperties,
+}
+
+impl Base for OrderedCollection {}
+impl Object for OrderedCollection {}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionPage {
+    #[serde(rename = "@context")]
+    context: serde_json::Value,
+    #[serde(rename = "type")]
+    kind: CollectionPageType,
+    items: Vec<serde_json::Value>,
+    #[serde(flatten)]
+    pub collection_props: CollectionProperties,
+    #[serde(flatten)]
+    pub collection_page_props: CollectionPageProperties,
+}
+
+impl Base for CollectionPage {}
+impl Object for CollectionPage {}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollectionPage {
+    #[serde(rename = "@context")]
+    context: serde_json::Value,
+    #[serde(rename = "type")]
+    kind: OrderedCollectionPageType,
+    items: Vec<serde_json::Value>,
+    #[serde(flatten)]
+    pub collection_props: CollectionProperties,
+    #[serde(flatten)]
+    pub collection_page_props: CollectionPageProperties,
+    #[serde(flatten)]
+    pub ordered_collection_page_props: OrderedCollectionPageProperties,
+}
+
+impl Base for OrderedCollectionPage {}
+impl Object for OrderedCollectionPage {}

src/collection/properties.rs

@@ -0,0 +1,105 @@
+use serde_json;
+
+use super::{Collection, CollectionPage};
+use error::Result;
+use link::Link;
+use Properties;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    total_items: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    current: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    first: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    last: Option<serde_json::Value>,
+}
+
+impl Properties for CollectionProperties {}
+
+impl CollectionProperties {
+    pub fn total_items(&self) -> Result<u64> {
+        self.get_item(|c| &c.total_items)
+    }
+
+    pub fn current(&self) -> Result<CollectionPage> {
+        self.get_item(|c| &c.current)
+    }
+
+    pub fn current_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.current)
+    }
+
+    pub fn first(&self) -> Result<CollectionPage> {
+        self.get_item(|c| &c.first)
+    }
+
+    pub fn first_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.first)
+    }
+
+    pub fn last(&self) -> Result<CollectionPage> {
+        self.get_item(|c| &c.last)
+    }
+
+    pub fn last_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.last)
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionPageProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    part_of: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    next: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    prev: Option<serde_json::Value>,
+}
+
+impl Properties for CollectionPageProperties {}
+
+impl CollectionPageProperties {
+    pub fn part_of(&self) -> Result<Collection> {
+        self.get_item(|c| &c.part_of)
+    }
+
+    pub fn part_of_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.part_of)
+    }
+
+    pub fn next(&self) -> Result<CollectionPage> {
+        self.get_item(|c| &c.next)
+    }
+
+    pub fn next_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.next)
+    }
+
+    pub fn prev(&self) -> Result<CollectionPage> {
+        self.get_item(|c| &c.prev)
+    }
+
+    pub fn prev_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|c| &c.prev)
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollectionPageProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    start_index: Option<serde_json::Value>,
+}
+
+impl Properties for OrderedCollectionPageProperties {}
+
+impl OrderedCollectionPageProperties {
+    pub fn start_index(&self) -> Result<u64> {
+        self.get_item(|c| &c.start_index)
+    }
+}

src/error.rs

@@ -0,0 +1,11 @@
+use std::result;
+
+#[derive(Copy, Clone, Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Key not present")]
+    NotFound,
+    #[fail(display = "Failed to deserialize data as requested type")]
+    Deserialize,
+}
+
+pub type Result<T> = result::Result<T, Error>;

src/lib.rs

@@ -0,0 +1,37 @@
+#[macro_use]
+extern crate failure;
+extern crate mime;
+extern crate serde;
+#[macro_use]
+extern crate serde_derive;
+#[macro_use]
+extern crate serde_json;
+
+pub fn context() -> serde_json::Value {
+    json!({
+        "one": "two",
+    })
+}
+
+pub trait Properties {
+    fn get_item<F, I>(&self, f: F) -> error::Result<I>
+    where
+        F: FnOnce(&Self) -> &Option<serde_json::Value>,
+        I: serde::de::DeserializeOwned,
+    {
+        if let &Some(ref item) = f(self) {
+            serde_json::from_value(item.clone()).map_err(|_| error::Error::Deserialize)
+        } else {
+            Err(error::Error::NotFound)
+        }
+    }
+}
+
+pub mod activity;
+pub mod actor;
+pub mod base;
+pub mod collection;
+pub mod error;
+pub mod link;
+pub mod location;
+pub mod object;

src/link/kind.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct MentionType;
+
+impl Serialize for MentionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Mention")
+    }
+}
+
+pub struct MentionTypeVisitor;
+
+impl<'de> Visitor<'de> for MentionTypeVisitor {
+    type Value = MentionType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Mention'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Mention" {
+            Ok(MentionType)
+        } else {
+            Err(de::Error::custom("Type not Mention"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MentionType {
+    fn deserialize<D>(deserializer: D) -> Result<MentionType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(MentionTypeVisitor)
+    }
+}

src/link/mod.rs

@@ -0,0 +1,20 @@
+use base::Base;
+
+mod kind;
+mod properties;
+pub use self::kind::*;
+pub use self::properties::*;
+
+pub trait Link: Base {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Mention {
+    #[serde(rename = "type")]
+    kind: MentionType,
+    #[serde(flatten)]
+    pub link_props: LinkProperties,
+}
+
+impl Base for Mention {}
+impl Link for Mention {}

src/link/properties.rs

@@ -0,0 +1,75 @@
+use mime;
+use serde_json;
+
+use error::{Error, Result};
+use link::Link;
+use object::Object;
+use Properties;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LinkProperties {
+    id: Option<serde_json::Value>,
+    href: Option<serde_json::Value>,
+    rel: Option<serde_json::Value>,
+    media_type: Option<serde_json::Value>,
+    name: Option<serde_json::Value>,
+    hreflang: Option<serde_json::Value>,
+    height: Option<serde_json::Value>,
+    width: Option<serde_json::Value>,
+    preview: Option<serde_json::Value>,
+}
+
+impl Properties for LinkProperties {}
+
+impl LinkProperties {
+    pub fn id(&self) -> Result<String> {
+        self.get_item(|l| &l.id)
+    }
+
+    pub fn href(&self) -> Result<String> {
+        self.get_item(|l| &l.href)
+    }
+
+    pub fn rel(&self) -> Result<String> {
+        self.get_item(|l| &l.rel)
+    }
+
+    pub fn rels(&self) -> Result<Vec<String>> {
+        self.get_item(|l| &l.rel)
+    }
+
+    pub fn media_type(&self) -> Result<mime::Mime> {
+        self.get_item::<_, String>(|l| &l.media_type)
+            .and_then(|s| s.parse().map_err(|_| Error::Deserialize))
+    }
+
+    pub fn name(&self) -> Result<String> {
+        self.get_item(|l| &l.name)
+    }
+
+    pub fn names(&self) -> Result<Vec<String>> {
+        self.get_item(|l| &l.name)
+    }
+
+    // TODO: Lang enum
+    pub fn hreflang(&self) -> Result<String> {
+        self.get_item(|l| &l.hreflang)
+    }
+
+    pub fn height(&self) -> Result<u64> {
+        self.get_item(|l| &l.height)
+    }
+
+    pub fn width(&self) -> Result<u64> {
+        self.get_item(|l| &l.width)
+    }
+
+    pub fn preview<O: Object>(&self) -> Result<O> {
+        self.get_item(|l| &l.preview)
+    }
+
+    pub fn preview_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|l| &l.preview)
+    }
+}

src/location.rs

@@ -0,0 +1,3 @@
+use base::Base;
+
+pub trait Location: Base {}

src/object/kind/article.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ArticleType;
+
+impl Serialize for ArticleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Article")
+    }
+}
+
+pub struct ArticleTypeVisitor;
+
+impl<'de> Visitor<'de> for ArticleTypeVisitor {
+    type Value = ArticleType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Article'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Article" {
+            Ok(ArticleType)
+        } else {
+            Err(de::Error::custom("Type not Article"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ArticleType {
+    fn deserialize<D>(deserializer: D) -> Result<ArticleType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ArticleTypeVisitor)
+    }
+}

src/object/kind/audio.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct AudioType;
+
+impl Serialize for AudioType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Audio")
+    }
+}
+
+pub struct AudioTypeVisitor;
+
+impl<'de> Visitor<'de> for AudioTypeVisitor {
+    type Value = AudioType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Audio'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Audio" {
+            Ok(AudioType)
+        } else {
+            Err(de::Error::custom("Type not Audio"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AudioType {
+    fn deserialize<D>(deserializer: D) -> Result<AudioType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AudioTypeVisitor)
+    }
+}

src/object/kind/document.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct DocumentType;
+
+impl Serialize for DocumentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Document")
+    }
+}
+
+pub struct DocumentTypeVisitor;
+
+impl<'de> Visitor<'de> for DocumentTypeVisitor {
+    type Value = DocumentType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Document'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Document" {
+            Ok(DocumentType)
+        } else {
+            Err(de::Error::custom("Type not Document"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DocumentType {
+    fn deserialize<D>(deserializer: D) -> Result<DocumentType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(DocumentTypeVisitor)
+    }
+}

src/object/kind/event.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct EventType;
+
+impl Serialize for EventType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Event")
+    }
+}
+
+pub struct EventTypeVisitor;
+
+impl<'de> Visitor<'de> for EventTypeVisitor {
+    type Value = EventType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Event'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Event" {
+            Ok(EventType)
+        } else {
+            Err(de::Error::custom("Type not Event"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventType {
+    fn deserialize<D>(deserializer: D) -> Result<EventType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(EventTypeVisitor)
+    }
+}

src/object/kind/image.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ImageType;
+
+impl Serialize for ImageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Image")
+    }
+}
+
+pub struct ImageTypeVisitor;
+
+impl<'de> Visitor<'de> for ImageTypeVisitor {
+    type Value = ImageType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Image'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Image" {
+            Ok(ImageType)
+        } else {
+            Err(de::Error::custom("Type not Image"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ImageType {
+    fn deserialize<D>(deserializer: D) -> Result<ImageType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ImageTypeVisitor)
+    }
+}

src/object/kind/mod.rs

@@ -0,0 +1,25 @@
+mod article;
+mod audio;
+mod document;
+mod event;
+mod image;
+mod note;
+mod page;
+mod place;
+mod profile;
+mod relationship;
+mod tombstone;
+mod video;
+
+pub use self::article::*;
+pub use self::audio::*;
+pub use self::document::*;
+pub use self::event::*;
+pub use self::image::*;
+pub use self::note::*;
+pub use self::page::*;
+pub use self::place::*;
+pub use self::profile::*;
+pub use self::relationship::*;
+pub use self::tombstone::*;
+pub use self::video::*;

src/object/kind/note.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct NoteType;
+
+impl Serialize for NoteType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Note")
+    }
+}
+
+pub struct NoteTypeVisitor;
+
+impl<'de> Visitor<'de> for NoteTypeVisitor {
+    type Value = NoteType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Note'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Note" {
+            Ok(NoteType)
+        } else {
+            Err(de::Error::custom("Type not Note"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NoteType {
+    fn deserialize<D>(deserializer: D) -> Result<NoteType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(NoteTypeVisitor)
+    }
+}

src/object/kind/page.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct PageType;
+
+impl Serialize for PageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Page")
+    }
+}
+
+pub struct PageTypeVisitor;
+
+impl<'de> Visitor<'de> for PageTypeVisitor {
+    type Value = PageType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Page'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Page" {
+            Ok(PageType)
+        } else {
+            Err(de::Error::custom("Type not Page"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for PageType {
+    fn deserialize<D>(deserializer: D) -> Result<PageType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(PageTypeVisitor)
+    }
+}

src/object/kind/place.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct PlaceType;
+
+impl Serialize for PlaceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Place")
+    }
+}
+
+pub struct PlaceTypeVisitor;
+
+impl<'de> Visitor<'de> for PlaceTypeVisitor {
+    type Value = PlaceType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Place'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Place" {
+            Ok(PlaceType)
+        } else {
+            Err(de::Error::custom("Type not Place"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for PlaceType {
+    fn deserialize<D>(deserializer: D) -> Result<PlaceType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(PlaceTypeVisitor)
+    }
+}

src/object/kind/profile.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct ProfileType;
+
+impl Serialize for ProfileType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Profile")
+    }
+}
+
+pub struct ProfileTypeVisitor;
+
+impl<'de> Visitor<'de> for ProfileTypeVisitor {
+    type Value = ProfileType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Profile'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Profile" {
+            Ok(ProfileType)
+        } else {
+            Err(de::Error::custom("Type not Profile"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ProfileType {
+    fn deserialize<D>(deserializer: D) -> Result<ProfileType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ProfileTypeVisitor)
+    }
+}

src/object/kind/relationship.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct RelationshipType;
+
+impl Serialize for RelationshipType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Relationship")
+    }
+}
+
+pub struct RelationshipTypeVisitor;
+
+impl<'de> Visitor<'de> for RelationshipTypeVisitor {
+    type Value = RelationshipType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Relationship'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Relationship" {
+            Ok(RelationshipType)
+        } else {
+            Err(de::Error::custom("Type not Relationship"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RelationshipType {
+    fn deserialize<D>(deserializer: D) -> Result<RelationshipType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(RelationshipTypeVisitor)
+    }
+}

src/object/kind/tombstone.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct TombstoneType;
+
+impl Serialize for TombstoneType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Tombstone")
+    }
+}
+
+pub struct TombstoneTypeVisitor;
+
+impl<'de> Visitor<'de> for TombstoneTypeVisitor {
+    type Value = TombstoneType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Tombstone'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Tombstone" {
+            Ok(TombstoneType)
+        } else {
+            Err(de::Error::custom("Type not Tombstone"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TombstoneType {
+    fn deserialize<D>(deserializer: D) -> Result<TombstoneType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(TombstoneTypeVisitor)
+    }
+}

src/object/kind/video.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use serde::{
+    de::{self, Deserialize, Deserializer, Visitor}, ser::{Serialize, Serializer},
+};
+
+#[derive(Clone, Debug)]
+pub struct VideoType;
+
+impl Serialize for VideoType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str("Video")
+    }
+}
+
+pub struct VideoTypeVisitor;
+
+impl<'de> Visitor<'de> for VideoTypeVisitor {
+    type Value = VideoType;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "The string 'Video'")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v == "Video" {
+            Ok(VideoType)
+        } else {
+            Err(de::Error::custom("Type not Video"))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for VideoType {
+    fn deserialize<D>(deserializer: D) -> Result<VideoType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(VideoTypeVisitor)
+    }
+}

src/object/mod.rs

@@ -0,0 +1,196 @@
+use serde_json;
+
+use base::Base;
+use error::{Error, Result};
+use link::Link;
+
+mod kind;
+mod properties;
+pub use self::kind::*;
+pub use self::properties::*;
+
+pub trait Object: Base {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Article {
+    #[serde(rename = "type")]
+    kind: ArticleType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Article {}
+impl Object for Article {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Audio {
+    #[serde(rename = "type")]
+    kind: AudioType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Audio {}
+impl Object for Audio {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Document {
+    #[serde(rename = "type")]
+    kind: DocumentType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Document {}
+impl Object for Document {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    #[serde(rename = "type")]
+    kind: EventType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Event {}
+impl Object for Event {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Image {
+    #[serde(rename = "type")]
+    kind: ImageType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Image {}
+impl Object for Image {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Note {
+    #[serde(rename = "type")]
+    kind: NoteType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Note {}
+impl Object for Note {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Page {
+    #[serde(rename = "type")]
+    kind: PageType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Page {}
+impl Object for Page {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Place {
+    #[serde(rename = "type")]
+    kind: PlaceType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub place: PlaceProperties,
+}
+
+impl Base for Place {}
+impl Object for Place {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Profile {
+    #[serde(rename = "type")]
+    kind: ProfileType,
+    describes: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Profile {
+    pub fn describes<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.describes.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Profile {}
+impl Object for Profile {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Relationship {
+    #[serde(rename = "type")]
+    kind: RelationshipType,
+    subject: serde_json::Value,
+    object: serde_json::Value,
+    relationship: serde_json::Value,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Relationship {
+    pub fn subject<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.subject.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn relationship<O: Object>(&self) -> Result<O> {
+        serde_json::from_value(self.relationship.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn subject_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.subject.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn object_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.object.clone()).map_err(|_| Error::Deserialize)
+    }
+
+    pub fn relationship_link<L: Link>(&self) -> Result<L> {
+        serde_json::from_value(self.relationship.clone()).map_err(|_| Error::Deserialize)
+    }
+}
+
+impl Base for Relationship {}
+impl Object for Relationship {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Tombstone {
+    #[serde(rename = "type")]
+    kind: TombstoneType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+    #[serde(flatten)]
+    pub tombstone_props: TombstoneProperties,
+}
+
+impl Base for Tombstone {}
+impl Object for Tombstone {}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Video {
+    #[serde(rename = "type")]
+    kind: VideoType,
+    #[serde(flatten)]
+    pub object_props: ObjectProperties,
+}
+
+impl Base for Video {}
+impl Object for Video {}

src/object/properties.rs

@@ -0,0 +1,442 @@
+use mime;
+use serde::de::DeserializeOwned;
+use serde_json;
+
+use collection::Collection;
+use error::{Error, Result};
+use link::Link;
+use object::{Image, Object};
+use Properties;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ObjectProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    id: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    attachment: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    attributed_to: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    audience: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    content: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@context")]
+    context: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    name: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    end_time: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    generator: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    icon: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    image: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    in_reply_to: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    location: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    preview: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    published: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    replies: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    start_time: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    summary: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tag: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    updated: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    to: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    bto: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    cc: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    bcc: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    media_type: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    duration: Option<serde_json::Value>,
+}
+
+impl Properties for ObjectProperties {}
+
+impl ObjectProperties {
+    pub fn id<D: DeserializeOwned>(&self) -> Result<D> {
+        self.get_item(|props| &props.id)
+    }
+
+    pub fn attachment<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.attachment)
+    }
+
+    pub fn attachments<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.attachment)
+    }
+
+    pub fn attachment_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.attachment)
+    }
+
+    pub fn attachment_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.attachment)
+    }
+
+    pub fn attributed_to<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.attributed_to)
+    }
+
+    pub fn attributed_tos<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.attributed_to)
+    }
+
+    pub fn attributed_to_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.attributed_to)
+    }
+
+    pub fn attributed_to_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.attributed_to)
+    }
+
+    pub fn audience<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.audience)
+    }
+
+    pub fn audiences<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.audience)
+    }
+
+    pub fn audience_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.audience)
+    }
+
+    pub fn audience_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.audience)
+    }
+
+    pub fn content(&self) -> Result<String> {
+        self.get_item(|props| &props.content)
+    }
+
+    pub fn contents(&self) -> Result<Vec<String>> {
+        self.get_item(|props| &props.content)
+    }
+
+    pub fn context(&self) -> Result<serde_json::Value> {
+        self.context.clone().ok_or(Error::NotFound)
+    }
+
+    pub fn name(&self) -> Result<String> {
+        self.get_item(|props| &props.name)
+    }
+
+    pub fn names(&self) -> Result<Vec<String>> {
+        self.get_item(|props| &props.name)
+    }
+
+    // TODO: DateTime<Utc>
+    pub fn end_time(&self) -> Result<String> {
+        self.get_item(|props| &props.end_time)
+    }
+
+    pub fn generator<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.generator)
+    }
+
+    pub fn generators<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.generator)
+    }
+
+    pub fn generator_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.generator)
+    }
+
+    pub fn generator_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.generator)
+    }
+
+    pub fn icon(&self) -> Result<Image> {
+        self.get_item(|props| &props.icon)
+    }
+
+    pub fn icons(&self) -> Result<Vec<Image>> {
+        self.get_item(|props| &props.icon)
+    }
+
+    pub fn icon_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.icon)
+    }
+
+    pub fn icon_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.icon)
+    }
+
+    pub fn image(&self) -> Result<Image> {
+        self.get_item(|props| &props.image)
+    }
+
+    pub fn images(&self) -> Result<Vec<Image>> {
+        self.get_item(|props| &props.image)
+    }
+
+    pub fn image_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.image)
+    }
+
+    pub fn image_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.image)
+    }
+
+    pub fn in_reply_to<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.in_reply_to)
+    }
+
+    pub fn in_reply_tos<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.in_reply_to)
+    }
+
+    pub fn in_reply_to_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.in_reply_to)
+    }
+
+    pub fn in_reply_to_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.in_reply_to)
+    }
+
+    pub fn location<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.location)
+    }
+
+    pub fn locations<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.location)
+    }
+
+    pub fn location_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.location)
+    }
+
+    pub fn location_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.location)
+    }
+
+    pub fn preview<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.preview)
+    }
+
+    pub fn previews<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.preview)
+    }
+
+    pub fn preview_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.preview)
+    }
+
+    pub fn preview_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.preview)
+    }
+
+    // TODO: DateTime<Utc>
+    pub fn published(&self) -> Result<String> {
+        self.get_item(|props| &props.published)
+    }
+
+    pub fn replies(&self) -> Result<Collection> {
+        self.get_item(|props| &props.replies)
+    }
+
+    // TODO: DateTime<Utc>
+    pub fn start_time(&self) -> Result<String> {
+        self.get_item(|props| &props.start_time)
+    }
+
+    pub fn summary(&self) -> Result<String> {
+        self.get_item(|props| &props.summary)
+    }
+
+    pub fn summaries(&self) -> Result<Vec<String>> {
+        self.get_item(|props| &props.summary)
+    }
+
+    pub fn tag<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.tag)
+    }
+
+    pub fn tags<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.tag)
+    }
+
+    pub fn tag_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.tag)
+    }
+
+    pub fn tag_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.tag)
+    }
+
+    // TODO: DateTime<Utc>
+    pub fn updated(&self) -> Result<String> {
+        self.get_item(|props| &props.updated)
+    }
+
+    pub fn url(&self) -> Result<String> {
+        self.get_item(|props| &props.url)
+    }
+
+    pub fn urls(&self) -> Result<Vec<String>> {
+        self.get_item(|props| &props.url)
+    }
+
+    pub fn url_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.url)
+    }
+
+    pub fn url_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.url)
+    }
+
+    pub fn to<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.to)
+    }
+
+    pub fn tos<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.to)
+    }
+
+    pub fn to_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.to)
+    }
+
+    pub fn to_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.to)
+    }
+
+    pub fn bto<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.bto)
+    }
+
+    pub fn btos<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.bto)
+    }
+
+    pub fn bto_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.bto)
+    }
+
+    pub fn bto_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.bto)
+    }
+
+    pub fn cc<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.cc)
+    }
+
+    pub fn ccs<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.cc)
+    }
+
+    pub fn cc_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.cc)
+    }
+
+    pub fn cc_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.cc)
+    }
+
+    pub fn bcc<O: Object>(&self) -> Result<O> {
+        self.get_item(|props| &props.bcc)
+    }
+
+    pub fn bccs<O: Object>(&self) -> Result<Vec<O>> {
+        self.get_item(|props| &props.bcc)
+    }
+
+    pub fn bcc_link<L: Link>(&self) -> Result<L> {
+        self.get_item(|props| &props.bcc)
+    }
+
+    pub fn bcc_links<L: Link>(&self) -> Result<Vec<L>> {
+        self.get_item(|props| &props.bcc)
+    }
+
+    pub fn media_type(&self) -> Result<mime::Mime> {
+        self.get_item::<_, String>(|props| &props.media_type)
+            .and_then(|s| s.parse().map_err(|_| Error::Deserialize))
+    }
+
+    // TODO: xsd:duration
+    pub fn duration(&self) -> Result<String> {
+        self.get_item(|props| &props.duration)
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaceProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    accuracy: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    altitude: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    latitude: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    longitude: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    radius: Option<f64>,
+}
+
+impl PlaceProperties {
+    pub fn accuracy(&self) -> Result<f64> {
+        self.accuracy.ok_or(Error::NotFound)
+    }
+
+    pub fn altitude(&self) -> Result<f64> {
+        self.altitude.ok_or(Error::NotFound)
+    }
+
+    pub fn latitude(&self) -> Result<f64> {
+        self.latitude.ok_or(Error::NotFound)
+    }
+
+    pub fn longitude(&self) -> Result<f64> {
+        self.longitude.ok_or(Error::NotFound)
+    }
+
+    pub fn radius(&self) -> Result<f64> {
+        self.radius.ok_or(Error::NotFound)
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TombstoneProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    former_type: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    deleted: Option<serde_json::Value>,
+}
+
+impl Properties for TombstoneProperties {}
+
+impl TombstoneProperties {
+    pub fn former_type(&self) -> Result<String> {
+        self.get_item(|t| &t.former_type)
+    }
+
+    pub fn former_types(&self) -> Result<Vec<String>> {
+        self.get_item(|t| &t.former_type)
+    }
+
+    // TODO: DateTime<Utc>
+    pub fn deleted(&self) -> Result<String> {
+        self.get_item(|t| &t.deleted)
+    }
+}