diff --git a/src/activity.rs b/src/activity.rs
index 3ced894..ce46518 100644
--- a/src/activity.rs
+++ b/src/activity.rs
@@ -1,7 +1,9 @@
 use crate::{
-    object::{AnyObject, ApObject, Object, ObjectMut, ObjectRef},
-    primitives::{OneOrMany, Unparsed},
-    traits::{self, Extends, UnparsedMut, UnparsedMutExt},
+    base::{AnyBase, AsBase, Base, Extends},
+    markers,
+    object::{ApObject, AsObject, Object},
+    primitives::OneOrMany,
+    unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
 };
 use std::convert::TryFrom;
 use typed_builder::TypedBuilder;
@@ -12,84 +14,54 @@ pub mod kind {
 
 use self::kind::*;
 
-pub trait ActivityRef<Kind>: traits::Activity {
+pub trait AsActivity<Kind>: markers::Activity {
     fn activity_ref(&self) -> &Activity<Kind>;
-}
-
-pub trait ActivityMut<Kind>: traits::Activity {
     fn activity_mut(&mut self) -> &mut Activity<Kind>;
 }
 
-pub trait ActorAndObjectRef: traits::Activity {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject>;
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject>;
+pub trait ActorAndObjectRef: markers::Activity {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase>;
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase>;
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
 }
 
-pub trait ActorAndObjectMut: traits::Activity {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject>;
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject>;
+pub trait TargetRef: markers::Activity {
+    fn target_field_ref(&self) -> &OneOrMany<AnyBase>;
+    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
 }
 
-pub trait TargetRef: traits::Activity {
-    fn target_field_ref(&self) -> &OneOrMany<AnyObject>;
+pub trait OriginRef: markers::Activity {
+    fn origin_field_ref(&self) -> &OneOrMany<AnyBase>;
+    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
 }
 
-pub trait TargetMut: traits::Activity {
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyObject>;
+pub trait OptTargetRef: markers::Activity {
+    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>>;
+    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>;
 }
 
-pub trait OriginRef: traits::Activity {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyObject>;
+pub trait OptOriginRef: markers::Activity {
+    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>>;
+    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>;
 }
 
-pub trait OriginMut: traits::Activity {
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyObject>;
-}
-
-pub trait OptTargetRef: traits::Activity {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyObject>>;
-}
-
-pub trait OptTargetMut: traits::Activity {
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>>;
-}
-
-pub trait OptOriginRef: traits::Activity {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyObject>>;
-}
-
-pub trait OptOriginMut: traits::Activity {
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>>;
-}
-
-pub trait QuestionRef: traits::Activity {
+pub trait AsQuestion: markers::Activity {
     fn question_ref(&self) -> &Question;
-}
-
-pub trait QuestionMut: traits::Activity {
     fn question_mut(&mut self) -> &mut Question;
 }
 
-pub trait ActivityRefExt<Kind>: ActivityRef<Kind> {
-    fn result<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
+pub trait ActivityExt<Kind>: AsActivity<Kind> {
+    fn result<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
         Kind: 'a,
     {
         self.activity_ref().result.as_ref()
     }
 
-    fn instrument<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.activity_ref().instrument.as_ref()
-    }
-}
-
-pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
     fn set_result<T>(&mut self, result: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.activity_mut().result = Some(result.into().into());
         self
@@ -98,7 +70,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
     fn set_many_results<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.activity_mut().result = Some(v.into());
@@ -107,7 +79,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
 
     fn add_result<T>(&mut self, result: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let c = match self.activity_mut().result.take() {
             Some(mut c) => {
@@ -120,7 +92,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
         self
     }
 
-    fn take_result(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_result(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.activity_mut().result.take()
     }
 
@@ -129,9 +101,16 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
         self
     }
 
+    fn instrument<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.activity_ref().instrument.as_ref()
+    }
+
     fn set_instrument<T>(&mut self, instrument: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.activity_mut().instrument = Some(instrument.into().into());
         self
@@ -140,7 +119,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
     fn set_many_instruments<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.activity_mut().instrument = Some(v.into());
@@ -149,7 +128,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
 
     fn add_instrument<T>(&mut self, instrument: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let c = match self.activity_mut().instrument.take() {
             Some(mut c) => {
@@ -162,7 +141,7 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
         self
     }
 
-    fn take_instrument(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_instrument(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.activity_mut().instrument.take()
     }
 
@@ -173,19 +152,13 @@ pub trait ActivityMutExt<Kind>: ActivityMut<Kind> {
 }
 
 pub trait ActorAndObjectRefExt: ActorAndObjectRef {
-    fn actor(&self) -> &OneOrMany<AnyObject> {
+    fn actor(&self) -> &OneOrMany<AnyBase> {
         self.actor_field_ref()
     }
 
-    fn object(&self) -> &OneOrMany<AnyObject> {
-        self.object_field_ref()
-    }
-}
-
-pub trait ActorAndObjectMutExt: ActorAndObjectMut {
     fn set_actor<T>(&mut self, actor: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.actor_field_mut() = actor.into().into();
         self
@@ -194,7 +167,7 @@ pub trait ActorAndObjectMutExt: ActorAndObjectMut {
     fn set_many_actors<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.actor_field_mut() = v.into();
@@ -203,15 +176,19 @@ pub trait ActorAndObjectMutExt: ActorAndObjectMut {
 
     fn add_actor<T>(&mut self, actor: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.actor_field_mut().add(actor.into());
         self
     }
 
+    fn object(&self) -> &OneOrMany<AnyBase> {
+        self.object_field_ref()
+    }
+
     fn set_object<T>(&mut self, object: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.object_field_mut() = object.into().into();
         self
@@ -220,7 +197,7 @@ pub trait ActorAndObjectMutExt: ActorAndObjectMut {
     fn set_many_objects<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.object_field_mut() = v.into();
@@ -229,7 +206,7 @@ pub trait ActorAndObjectMutExt: ActorAndObjectMut {
 
     fn add_object<T>(&mut self, object: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_field_mut().add(object.into());
         self
@@ -237,15 +214,13 @@ pub trait ActorAndObjectMutExt: ActorAndObjectMut {
 }
 
 pub trait TargetRefExt: TargetRef {
-    fn target(&self) -> &OneOrMany<AnyObject> {
+    fn target(&self) -> &OneOrMany<AnyBase> {
         self.target_field_ref()
     }
-}
 
-pub trait TargetMutExt: TargetMut {
     fn set_target<T>(&mut self, target: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.target_field_mut() = target.into().into();
         self
@@ -254,7 +229,7 @@ pub trait TargetMutExt: TargetMut {
     fn set_many_targets<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.target_field_mut() = v.into();
@@ -263,7 +238,7 @@ pub trait TargetMutExt: TargetMut {
 
     fn add_target<T>(&mut self, target: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.target_field_mut().add(target.into());
         self
@@ -271,15 +246,13 @@ pub trait TargetMutExt: TargetMut {
 }
 
 pub trait OriginRefExt: OriginRef {
-    fn origin(&self) -> &OneOrMany<AnyObject> {
+    fn origin(&self) -> &OneOrMany<AnyBase> {
         self.origin_field_ref()
     }
-}
 
-pub trait OriginMutExt: OriginMut {
     fn set_origin<T>(&mut self, origin: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.origin_field_mut() = origin.into().into();
         self
@@ -288,7 +261,7 @@ pub trait OriginMutExt: OriginMut {
     fn set_many_origins<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.origin_field_mut() = v.into();
@@ -297,7 +270,7 @@ pub trait OriginMutExt: OriginMut {
 
     fn add_origin<T>(&mut self, origin: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.origin_field_mut().add(origin.into());
         self
@@ -305,15 +278,13 @@ pub trait OriginMutExt: OriginMut {
 }
 
 pub trait OptTargetRefExt: OptTargetRef {
-    fn target(&self) -> Option<&OneOrMany<AnyObject>> {
+    fn target(&self) -> Option<&OneOrMany<AnyBase>> {
         self.target_field_ref().as_ref()
     }
-}
 
-pub trait OptTargetMutExt: OptTargetMut {
     fn set_target<T>(&mut self, target: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.target_field_mut() = Some(target.into().into());
         self
@@ -322,7 +293,7 @@ pub trait OptTargetMutExt: OptTargetMut {
     fn set_many_targets<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.target_field_mut() = Some(v.into());
@@ -331,7 +302,7 @@ pub trait OptTargetMutExt: OptTargetMut {
 
     fn add_target<T>(&mut self, target: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let c = match self.target_field_mut().take() {
             Some(mut c) => {
@@ -344,7 +315,7 @@ pub trait OptTargetMutExt: OptTargetMut {
         self
     }
 
-    fn take_target(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_target(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.target_field_mut().take()
     }
 
@@ -355,15 +326,13 @@ pub trait OptTargetMutExt: OptTargetMut {
 }
 
 pub trait OptOriginRefExt: OptOriginRef {
-    fn origin(&self) -> Option<&OneOrMany<AnyObject>> {
+    fn origin(&self) -> Option<&OneOrMany<AnyBase>> {
         self.origin_field_ref().as_ref()
     }
-}
 
-pub trait OptOriginMutExt: OptOriginMut {
     fn set_origin<T>(&mut self, origin: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         *self.origin_field_mut() = Some(origin.into().into());
         self
@@ -372,7 +341,7 @@ pub trait OptOriginMutExt: OptOriginMut {
     fn set_many_origins<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         *self.origin_field_mut() = Some(v.into());
@@ -381,7 +350,7 @@ pub trait OptOriginMutExt: OptOriginMut {
 
     fn add_origin<T>(&mut self, origin: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let c = match self.origin_field_mut().take() {
             Some(mut c) => {
@@ -394,7 +363,7 @@ pub trait OptOriginMutExt: OptOriginMut {
         self
     }
 
-    fn take_origin(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_origin(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.origin_field_mut().take()
     }
 
@@ -404,20 +373,18 @@ pub trait OptOriginMutExt: OptOriginMut {
     }
 }
 
-pub trait QuestionRefExt: QuestionRef {
-    fn one_of(&self) -> Option<&OneOrMany<AnyObject>> {
+pub trait QuestionExt: AsQuestion {
+    fn one_of(&self) -> Option<&OneOrMany<AnyBase>> {
         self.question_ref().one_of.as_ref()
     }
 
-    fn any_of(&self) -> Option<&OneOrMany<AnyObject>> {
+    fn any_of(&self) -> Option<&OneOrMany<AnyBase>> {
         self.question_ref().any_of.as_ref()
     }
-}
 
-pub trait QuestionMutExt: QuestionMut {
     fn set_one_of<T>(&mut self, one_of: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.question_mut().one_of = Some(one_of.into().into());
         self
@@ -426,7 +393,7 @@ pub trait QuestionMutExt: QuestionMut {
     fn set_many_one_ofs<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.question_mut().one_of = Some(v.into());
@@ -435,7 +402,7 @@ pub trait QuestionMutExt: QuestionMut {
 
     fn add_one_of<T>(&mut self, one_of: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v = match self.question_mut().one_of.take() {
             Some(mut v) => {
@@ -448,7 +415,7 @@ pub trait QuestionMutExt: QuestionMut {
         self
     }
 
-    fn take_one_of(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_one_of(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.question_mut().one_of.take()
     }
 
@@ -459,7 +426,7 @@ pub trait QuestionMutExt: QuestionMut {
 
     fn set_any_of<T>(&mut self, any_of: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.question_mut().any_of = Some(any_of.into().into());
         self
@@ -468,7 +435,7 @@ pub trait QuestionMutExt: QuestionMut {
     fn set_many_any_ofs<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.question_mut().any_of = Some(v.into());
@@ -477,7 +444,7 @@ pub trait QuestionMutExt: QuestionMut {
 
     fn add_any_of<T>(&mut self, any_of: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v = match self.question_mut().any_of.take() {
             Some(mut v) => {
@@ -490,7 +457,7 @@ pub trait QuestionMutExt: QuestionMut {
         self
     }
 
-    fn take_any_of(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_any_of(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.question_mut().any_of.take()
     }
 
@@ -532,11 +499,11 @@ pub type Remove = ActorAndObjectOptOriginAndTarget<RemoveType>;
 pub struct Activity<Kind> {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub result: Option<OneOrMany<AnyObject>>,
+    pub result: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub instrument: Option<OneOrMany<AnyObject>>,
+    pub instrument: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Object<Kind>,
@@ -547,10 +514,10 @@ pub struct Activity<Kind> {
 #[builder(doc)]
 pub struct ActorAndObject<Kind> {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub object: OneOrMany<AnyObject>,
+    pub object: OneOrMany<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Activity<Kind>,
@@ -561,10 +528,10 @@ pub struct ActorAndObject<Kind> {
 #[builder(doc)]
 pub struct Arrive {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub origin: OneOrMany<AnyObject>,
+    pub origin: OneOrMany<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Activity<ArriveType>,
@@ -575,13 +542,13 @@ pub struct Arrive {
 #[builder(doc)]
 pub struct Invite {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub object: OneOrMany<AnyObject>,
+    pub object: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub target: OneOrMany<AnyObject>,
+    pub target: OneOrMany<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Activity<InviteType>,
@@ -592,14 +559,14 @@ pub struct Invite {
 #[builder(doc)]
 pub struct Delete {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub object: OneOrMany<AnyObject>,
+    pub object: OneOrMany<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub origin: Option<OneOrMany<AnyObject>>,
+    pub origin: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Activity<DeleteType>,
@@ -610,18 +577,18 @@ pub struct Delete {
 #[builder(doc)]
 pub struct ActorAndObjectOptOriginAndTarget<Kind> {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub object: OneOrMany<AnyObject>,
+    pub object: OneOrMany<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub origin: Option<OneOrMany<AnyObject>>,
+    pub origin: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub target: Option<OneOrMany<AnyObject>>,
+    pub target: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Activity<Kind>,
@@ -632,14 +599,14 @@ pub struct ActorAndObjectOptOriginAndTarget<Kind> {
 #[builder(doc)]
 pub struct ActorAndObjectOptTarget<Kind> {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[builder(setter(into))]
-    pub object: OneOrMany<AnyObject>,
+    pub object: OneOrMany<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub target: Option<OneOrMany<AnyObject>>,
+    pub target: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Activity<Kind>,
@@ -650,15 +617,15 @@ pub struct ActorAndObjectOptTarget<Kind> {
 #[builder(doc)]
 pub struct Travel {
     #[builder(setter(into))]
-    pub actor: OneOrMany<AnyObject>,
+    pub actor: OneOrMany<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub origin: Option<OneOrMany<AnyObject>>,
+    pub origin: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub target: Option<OneOrMany<AnyObject>>,
+    pub target: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Activity<TravelType>,
@@ -670,11 +637,11 @@ pub struct Travel {
 pub struct Question {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub one_of: Option<OneOrMany<AnyObject>>,
+    pub one_of: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub any_of: Option<OneOrMany<AnyObject>>,
+    pub any_of: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Activity<QuestionType>,
@@ -957,54 +924,65 @@ impl Question {
     }
 }
 
-impl<Kind> traits::Base for Activity<Kind> {}
-impl<Kind> traits::Object for Activity<Kind> {}
-impl<Kind> traits::Activity for Activity<Kind> {}
+impl<Kind> markers::Base for Activity<Kind> {}
+impl<Kind> markers::Object for Activity<Kind> {}
+impl<Kind> markers::Activity for Activity<Kind> {}
 
-impl<Kind> traits::Base for ActorAndObject<Kind> {}
-impl<Kind> traits::Object for ActorAndObject<Kind> {}
-impl<Kind> traits::Activity for ActorAndObject<Kind> {}
+impl<Kind> markers::Base for ActorAndObject<Kind> {}
+impl<Kind> markers::Object for ActorAndObject<Kind> {}
+impl<Kind> markers::Activity for ActorAndObject<Kind> {}
 
-impl<Kind> traits::Base for ActorAndObjectOptTarget<Kind> {}
-impl<Kind> traits::Object for ActorAndObjectOptTarget<Kind> {}
-impl<Kind> traits::Activity for ActorAndObjectOptTarget<Kind> {}
+impl<Kind> markers::Base for ActorAndObjectOptTarget<Kind> {}
+impl<Kind> markers::Object for ActorAndObjectOptTarget<Kind> {}
+impl<Kind> markers::Activity for ActorAndObjectOptTarget<Kind> {}
 
-impl<Kind> traits::Base for ActorAndObjectOptOriginAndTarget<Kind> {}
-impl<Kind> traits::Object for ActorAndObjectOptOriginAndTarget<Kind> {}
-impl<Kind> traits::Activity for ActorAndObjectOptOriginAndTarget<Kind> {}
+impl<Kind> markers::Base for ActorAndObjectOptOriginAndTarget<Kind> {}
+impl<Kind> markers::Object for ActorAndObjectOptOriginAndTarget<Kind> {}
+impl<Kind> markers::Activity for ActorAndObjectOptOriginAndTarget<Kind> {}
 
-impl traits::Base for Arrive {}
-impl traits::Object for Arrive {}
-impl traits::Activity for Arrive {}
-impl traits::IntransitiveActivity for Arrive {}
+impl markers::Base for Arrive {}
+impl markers::Object for Arrive {}
+impl markers::Activity for Arrive {}
+impl markers::IntransitiveActivity for Arrive {}
 
-impl traits::Base for Invite {}
-impl traits::Object for Invite {}
-impl traits::Activity for Invite {}
+impl markers::Base for Invite {}
+impl markers::Object for Invite {}
+impl markers::Activity for Invite {}
 
-impl traits::Base for Delete {}
-impl traits::Object for Delete {}
-impl traits::Activity for Delete {}
+impl markers::Base for Delete {}
+impl markers::Object for Delete {}
+impl markers::Activity for Delete {}
 
-impl traits::Base for Travel {}
-impl traits::Object for Travel {}
-impl traits::Activity for Travel {}
-impl traits::IntransitiveActivity for Travel {}
+impl markers::Base for Travel {}
+impl markers::Object for Travel {}
+impl markers::Activity for Travel {}
+impl markers::IntransitiveActivity for Travel {}
 
-impl traits::Base for Question {}
-impl traits::Object for Question {}
-impl traits::Activity for Question {}
-impl traits::IntransitiveActivity for Question {}
+impl markers::Base for Question {}
+impl markers::Object for Question {}
+impl markers::Activity for Question {}
+impl markers::IntransitiveActivity for Question {}
 
-impl<Kind> Extends<Object<Kind>> for Activity<Kind> {
+impl<Inner> markers::Activity for ApObject<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for ApObject<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
+
+impl<Kind> Extends<Kind> for Activity<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1024,15 +1002,20 @@ impl<Kind> TryFrom<Activity<Kind>> for Object<Kind> {
     }
 }
 
-impl<Kind> Extends<Object<Kind>> for ActorAndObject<Kind> {
+impl<Kind> Extends<Kind> for ActorAndObject<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1052,15 +1035,17 @@ impl<Kind> TryFrom<ActorAndObject<Kind>> for Object<Kind> {
     }
 }
 
-impl Extends<Object<ArriveType>> for Arrive {
+impl Extends<ArriveType> for Arrive {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<ArriveType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<ArriveType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<ArriveType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<ArriveType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1080,15 +1065,17 @@ impl TryFrom<Arrive> for Object<ArriveType> {
     }
 }
 
-impl Extends<Object<InviteType>> for Invite {
+impl Extends<InviteType> for Invite {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<InviteType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<InviteType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<InviteType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<InviteType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1108,15 +1095,17 @@ impl TryFrom<Invite> for Object<InviteType> {
     }
 }
 
-impl Extends<Object<DeleteType>> for Delete {
+impl Extends<DeleteType> for Delete {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<DeleteType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<DeleteType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<DeleteType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<DeleteType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1136,15 +1125,20 @@ impl TryFrom<Delete> for Object<DeleteType> {
     }
 }
 
-impl<Kind> Extends<Object<Kind>> for ActorAndObjectOptOriginAndTarget<Kind> {
+impl<Kind> Extends<Kind> for ActorAndObjectOptOriginAndTarget<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1164,15 +1158,20 @@ impl<Kind> TryFrom<ActorAndObjectOptOriginAndTarget<Kind>> for Object<Kind> {
     }
 }
 
-impl<Kind> Extends<Object<Kind>> for ActorAndObjectOptTarget<Kind> {
+impl<Kind> Extends<Kind> for ActorAndObjectOptTarget<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1192,15 +1191,17 @@ impl<Kind> TryFrom<ActorAndObjectOptTarget<Kind>> for Object<Kind> {
     }
 }
 
-impl Extends<Object<TravelType>> for Travel {
+impl Extends<TravelType> for Travel {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<TravelType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<TravelType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<TravelType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<TravelType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1220,15 +1221,17 @@ impl TryFrom<Travel> for Object<TravelType> {
     }
 }
 
-impl Extends<Object<QuestionType>> for Question {
+impl Extends<QuestionType> for Question {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<QuestionType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<QuestionType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<QuestionType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<QuestionType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -1302,465 +1305,464 @@ impl UnparsedMut for Question {
     }
 }
 
-impl<Kind> ObjectRef<Kind> for Activity<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
-        &self.inner
+impl<Kind> AsBase<Kind> for Activity<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
     }
 }
 
-impl<Kind> ObjectMut<Kind> for Activity<Kind> {
+impl<Kind> AsObject<Kind> for Activity<Kind> {
+    fn object_ref(&self) -> &Object<Kind> {
+        &self.inner
+    }
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> ActivityRef<Kind> for Activity<Kind> {
+impl<Kind> AsActivity<Kind> for Activity<Kind> {
     fn activity_ref(&self) -> &Activity<Kind> {
         self
     }
-}
 
-impl<Kind> ActivityMut<Kind> for Activity<Kind> {
     fn activity_mut(&mut self) -> &mut Activity<Kind> {
         self
     }
 }
 
-impl<Kind> ObjectRef<Kind> for ActorAndObject<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
-        self.inner.object_ref()
+impl<Kind> AsBase<Kind> for ActorAndObject<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
     }
 }
 
-impl<Kind> ObjectMut<Kind> for ActorAndObject<Kind> {
+impl<Kind> AsObject<Kind> for ActorAndObject<Kind> {
+    fn object_ref(&self) -> &Object<Kind> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> ActivityRef<Kind> for ActorAndObject<Kind> {
+impl<Kind> AsActivity<Kind> for ActorAndObject<Kind> {
     fn activity_ref(&self) -> &Activity<Kind> {
         &self.inner
     }
-}
 
-impl<Kind> ActivityMut<Kind> for ActorAndObject<Kind> {
     fn activity_mut(&mut self) -> &mut Activity<Kind> {
         &mut self.inner
     }
 }
 
 impl<Kind> ActorAndObjectRef for ActorAndObject<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.actor
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.object
     }
-}
 
-impl<Kind> ActorAndObjectMut for ActorAndObject<Kind> {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.actor
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.object
     }
 }
 
-impl<Kind> ObjectRef<Kind> for ActorAndObjectOptTarget<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
-        self.inner.object_ref()
+impl<Kind> AsBase<Kind> for ActorAndObjectOptTarget<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
     }
 }
 
-impl<Kind> ObjectMut<Kind> for ActorAndObjectOptTarget<Kind> {
+impl<Kind> AsObject<Kind> for ActorAndObjectOptTarget<Kind> {
+    fn object_ref(&self) -> &Object<Kind> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> ActivityRef<Kind> for ActorAndObjectOptTarget<Kind> {
+impl<Kind> AsActivity<Kind> for ActorAndObjectOptTarget<Kind> {
     fn activity_ref(&self) -> &Activity<Kind> {
         &self.inner
     }
-}
 
-impl<Kind> ActivityMut<Kind> for ActorAndObjectOptTarget<Kind> {
     fn activity_mut(&mut self) -> &mut Activity<Kind> {
         &mut self.inner
     }
 }
 
 impl<Kind> ActorAndObjectRef for ActorAndObjectOptTarget<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.actor
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.object
     }
-}
 
-impl<Kind> ActorAndObjectMut for ActorAndObjectOptTarget<Kind> {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.actor
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.object
     }
 }
 
 impl<Kind> OptTargetRef for ActorAndObjectOptTarget<Kind> {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.target
     }
-}
 
-impl<Kind> OptTargetMut for ActorAndObjectOptTarget<Kind> {
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.target
     }
 }
 
-impl<Kind> ObjectRef<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
-        self.inner.object_ref()
+impl<Kind> AsBase<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
     }
 }
 
-impl<Kind> ObjectMut<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
+impl<Kind> AsObject<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
+    fn object_ref(&self) -> &Object<Kind> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> ActivityRef<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
+impl<Kind> AsActivity<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
     fn activity_ref(&self) -> &Activity<Kind> {
         &self.inner
     }
-}
 
-impl<Kind> ActivityMut<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
     fn activity_mut(&mut self) -> &mut Activity<Kind> {
         &mut self.inner
     }
 }
 
 impl<Kind> ActorAndObjectRef for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.actor
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.object
     }
-}
 
-impl<Kind> ActorAndObjectMut for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.actor
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.object
     }
 }
 
 impl<Kind> OptTargetRef for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.target
     }
-}
 
-impl<Kind> OptTargetMut for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.target
     }
 }
 
 impl<Kind> OptOriginRef for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.origin
     }
-}
 
-impl<Kind> OptOriginMut for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.origin
     }
 }
 
-impl ObjectRef<ArriveType> for Arrive {
-    fn object_ref(&self) -> &Object<ArriveType> {
-        self.inner.object_ref()
+impl AsBase<ArriveType> for Arrive {
+    fn base_ref(&self) -> &Base<ArriveType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<ArriveType> {
+        self.inner.base_mut()
     }
 }
 
-impl ObjectMut<ArriveType> for Arrive {
+impl AsObject<ArriveType> for Arrive {
+    fn object_ref(&self) -> &Object<ArriveType> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<ArriveType> {
         self.inner.object_mut()
     }
 }
 
-impl ActivityRef<ArriveType> for Arrive {
+impl AsActivity<ArriveType> for Arrive {
     fn activity_ref(&self) -> &Activity<ArriveType> {
         &self.inner
     }
-}
 
-impl ActivityMut<ArriveType> for Arrive {
     fn activity_mut(&mut self) -> &mut Activity<ArriveType> {
         &mut self.inner
     }
 }
 
 impl OriginRef for Arrive {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.origin
     }
-}
 
-impl OriginMut for Arrive {
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.origin
     }
 }
 
-impl ObjectRef<InviteType> for Invite {
-    fn object_ref(&self) -> &Object<InviteType> {
-        self.inner.object_ref()
+impl AsBase<InviteType> for Invite {
+    fn base_ref(&self) -> &Base<InviteType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<InviteType> {
+        self.inner.base_mut()
     }
 }
 
-impl ObjectMut<InviteType> for Invite {
+impl AsObject<InviteType> for Invite {
+    fn object_ref(&self) -> &Object<InviteType> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<InviteType> {
         self.inner.object_mut()
     }
 }
 
-impl ActivityRef<InviteType> for Invite {
+impl AsActivity<InviteType> for Invite {
     fn activity_ref(&self) -> &Activity<InviteType> {
         &self.inner
     }
-}
 
-impl ActivityMut<InviteType> for Invite {
     fn activity_mut(&mut self) -> &mut Activity<InviteType> {
         &mut self.inner
     }
 }
 
 impl ActorAndObjectRef for Invite {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.actor
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.object
     }
-}
 
-impl ActorAndObjectMut for Invite {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.actor
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.object
     }
 }
 
 impl TargetRef for Invite {
-    fn target_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.target
     }
-}
 
-impl TargetMut for Invite {
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.target
     }
 }
 
-impl ObjectRef<DeleteType> for Delete {
-    fn object_ref(&self) -> &Object<DeleteType> {
-        self.inner.object_ref()
+impl AsBase<DeleteType> for Delete {
+    fn base_ref(&self) -> &Base<DeleteType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<DeleteType> {
+        self.inner.base_mut()
     }
 }
 
-impl ObjectMut<DeleteType> for Delete {
+impl AsObject<DeleteType> for Delete {
+    fn object_ref(&self) -> &Object<DeleteType> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<DeleteType> {
         self.inner.object_mut()
     }
 }
 
-impl ActivityRef<DeleteType> for Delete {
+impl AsActivity<DeleteType> for Delete {
     fn activity_ref(&self) -> &Activity<DeleteType> {
         &self.inner
     }
-}
 
-impl ActivityMut<DeleteType> for Delete {
     fn activity_mut(&mut self) -> &mut Activity<DeleteType> {
         &mut self.inner
     }
 }
 
 impl ActorAndObjectRef for Delete {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.actor
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         &self.object
     }
-}
 
-impl ActorAndObjectMut for Delete {
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.actor
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         &mut self.object
     }
 }
 
 impl OptOriginRef for Delete {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.origin
     }
-}
 
-impl OptOriginMut for Delete {
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.origin
     }
 }
 
-impl ObjectRef<TravelType> for Travel {
-    fn object_ref(&self) -> &Object<TravelType> {
-        self.inner.object_ref()
+impl AsBase<TravelType> for Travel {
+    fn base_ref(&self) -> &Base<TravelType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<TravelType> {
+        self.inner.base_mut()
     }
 }
 
-impl ObjectMut<TravelType> for Travel {
+impl AsObject<TravelType> for Travel {
+    fn object_ref(&self) -> &Object<TravelType> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<TravelType> {
         self.inner.object_mut()
     }
 }
 
-impl ActivityRef<TravelType> for Travel {
+impl AsActivity<TravelType> for Travel {
     fn activity_ref(&self) -> &Activity<TravelType> {
         self.inner.activity_ref()
     }
-}
 
-impl ActivityMut<TravelType> for Travel {
     fn activity_mut(&mut self) -> &mut Activity<TravelType> {
         self.inner.activity_mut()
     }
 }
 
 impl OptTargetRef for Travel {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.target
     }
-}
 
-impl OptTargetMut for Travel {
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.target
     }
 }
 
 impl OptOriginRef for Travel {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         &self.origin
     }
-}
 
-impl OptOriginMut for Travel {
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         &mut self.origin
     }
 }
 
-impl ObjectRef<QuestionType> for Question {
-    fn object_ref(&self) -> &Object<QuestionType> {
-        self.inner.object_ref()
+impl AsBase<QuestionType> for Question {
+    fn base_ref(&self) -> &Base<QuestionType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<QuestionType> {
+        self.inner.base_mut()
     }
 }
 
-impl ObjectMut<QuestionType> for Question {
+impl AsObject<QuestionType> for Question {
+    fn object_ref(&self) -> &Object<QuestionType> {
+        self.inner.object_ref()
+    }
+
     fn object_mut(&mut self) -> &mut Object<QuestionType> {
         self.inner.object_mut()
     }
 }
 
-impl ActivityRef<QuestionType> for Question {
+impl AsActivity<QuestionType> for Question {
     fn activity_ref(&self) -> &Activity<QuestionType> {
         &self.inner
     }
-}
 
-impl ActivityMut<QuestionType> for Question {
     fn activity_mut(&mut self) -> &mut Activity<QuestionType> {
         &mut self.inner
     }
 }
 
-impl QuestionRef for Question {
+impl AsQuestion for Question {
     fn question_ref(&self) -> &Question {
         self
     }
-}
 
-impl QuestionMut for Question {
     fn question_mut(&mut self) -> &mut Question {
         self
     }
 }
 
-impl<T, Kind> ActivityRefExt<Kind> for T where T: ActivityRef<Kind> {}
-impl<T, Kind> ActivityMutExt<Kind> for T where T: ActivityMut<Kind> {}
-
-impl<T> ActorAndObjectRefExt for T where T: ActorAndObjectRef {}
-impl<T> ActorAndObjectMutExt for T where T: ActorAndObjectMut {}
-
-impl<T> TargetRefExt for T where T: TargetRef {}
-impl<T> TargetMutExt for T where T: TargetMut {}
-
-impl<T> OriginRefExt for T where T: OriginRef {}
-impl<T> OriginMutExt for T where T: OriginMut {}
-
-impl<T> OptTargetRefExt for T where T: OptTargetRef {}
-impl<T> OptTargetMutExt for T where T: OptTargetMut {}
-
-impl<T> OptOriginRefExt for T where T: OptOriginRef {}
-impl<T> OptOriginMutExt for T where T: OptOriginMut {}
-
-impl<T> QuestionRefExt for T where T: QuestionRef {}
-impl<T> QuestionMutExt for T where T: QuestionMut {}
-
-impl<Inner> traits::Activity for ApObject<Inner> where Inner: traits::Activity {}
-
-impl<Inner, Kind> ActivityRef<Kind> for ApObject<Inner>
+impl<Inner, Kind> AsActivity<Kind> for ApObject<Inner>
 where
-    Inner: ActivityRef<Kind>,
+    Inner: AsActivity<Kind>,
 {
     fn activity_ref(&self) -> &Activity<Kind> {
         self.inner.activity_ref()
     }
-}
-impl<Inner, Kind> ActivityMut<Kind> for ApObject<Inner>
-where
-    Inner: ActivityMut<Kind>,
-{
+
     fn activity_mut(&mut self) -> &mut Activity<Kind> {
         self.inner.activity_mut()
     }
@@ -1770,23 +1772,19 @@ impl<Inner> ActorAndObjectRef for ApObject<Inner>
 where
     Inner: ActorAndObjectRef,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
         self.inner.actor_field_ref()
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
         self.inner.object_field_ref()
     }
-}
-impl<Inner> ActorAndObjectMut for ApObject<Inner>
-where
-    Inner: ActorAndObjectMut,
-{
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+
+    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         self.inner.actor_field_mut()
     }
 
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         self.inner.object_field_mut()
     }
 }
@@ -1795,15 +1793,11 @@ impl<Inner> TargetRef for ApObject<Inner>
 where
     Inner: TargetRef,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
         self.inner.target_field_ref()
     }
-}
-impl<Inner> TargetMut for ApObject<Inner>
-where
-    Inner: TargetMut,
-{
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+
+    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         self.inner.target_field_mut()
     }
 }
@@ -1812,15 +1806,11 @@ impl<Inner> OriginRef for ApObject<Inner>
 where
     Inner: OriginRef,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyObject> {
+    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
         self.inner.origin_field_ref()
     }
-}
-impl<Inner> OriginMut for ApObject<Inner>
-where
-    Inner: OriginMut,
-{
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyObject> {
+
+    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
         self.inner.origin_field_mut()
     }
 }
@@ -1829,15 +1819,11 @@ impl<Inner> OptTargetRef for ApObject<Inner>
 where
     Inner: OptTargetRef,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         self.inner.target_field_ref()
     }
-}
-impl<Inner> OptTargetMut for ApObject<Inner>
-where
-    Inner: OptTargetMut,
-{
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+
+    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         self.inner.target_field_mut()
     }
 }
@@ -1846,32 +1832,32 @@ impl<Inner> OptOriginRef for ApObject<Inner>
 where
     Inner: OptOriginRef,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyObject>> {
+    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
         self.inner.origin_field_ref()
     }
-}
-impl<Inner> OptOriginMut for ApObject<Inner>
-where
-    Inner: OptOriginMut,
-{
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyObject>> {
+
+    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
         self.inner.origin_field_mut()
     }
 }
 
-impl<Inner> QuestionRef for ApObject<Inner>
+impl<Inner> AsQuestion for ApObject<Inner>
 where
-    Inner: QuestionRef,
+    Inner: AsQuestion,
 {
     fn question_ref(&self) -> &Question {
         self.inner.question_ref()
     }
-}
-impl<Inner> QuestionMut for ApObject<Inner>
-where
-    Inner: QuestionMut,
-{
+
     fn question_mut(&mut self) -> &mut Question {
         self.inner.question_mut()
     }
 }
+
+impl<T, Kind> ActivityExt<Kind> for T where T: AsActivity<Kind> {}
+impl<T> ActorAndObjectRefExt for T where T: ActorAndObjectRef {}
+impl<T> TargetRefExt for T where T: TargetRef {}
+impl<T> OriginRefExt for T where T: OriginRef {}
+impl<T> OptTargetRefExt for T where T: OptTargetRef {}
+impl<T> OptOriginRefExt for T where T: OptOriginRef {}
+impl<T> QuestionExt for T where T: AsQuestion {}
diff --git a/src/actor.rs b/src/actor.rs
index aac0949..45860ea 100644
--- a/src/actor.rs
+++ b/src/actor.rs
@@ -1,7 +1,9 @@
 use crate::{
-    object::{Object, ObjectMut, ObjectRef},
-    primitives::{OneOrMany, Unparsed, XsdAnyUri, XsdString},
-    traits::{self, Extends, UnparsedMut, UnparsedMutExt},
+    base::{AsBase, Base, Extends},
+    markers,
+    object::{ApObject, AsApObject, AsObject, Object},
+    primitives::{OneOrMany, XsdAnyUri, XsdString},
+    unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
 };
 use typed_builder::TypedBuilder;
 
@@ -11,15 +13,12 @@ pub mod kind {
 
 use self::kind::*;
 
-pub trait ApActorRef<Inner>: traits::Actor {
+pub trait AsApActor<Inner>: markers::Actor {
     fn ap_actor_ref(&self) -> &ApActor<Inner>;
-}
-
-pub trait ApActorMut<Inner>: traits::Actor {
     fn ap_actor_mut(&mut self) -> &mut ApActor<Inner>;
 }
 
-pub trait ApActorRefExt<Inner>: ApActorRef<Inner> {
+pub trait ApActorExt<Inner>: AsApActor<Inner> {
     fn inbox<'a>(&'a self) -> &'a XsdAnyUri
     where
         Inner: 'a,
@@ -27,6 +26,11 @@ pub trait ApActorRefExt<Inner>: ApActorRef<Inner> {
         &self.ap_actor_ref().inbox
     }
 
+    fn set_inbox(&mut self, inbox: XsdAnyUri) -> &mut Self {
+        self.ap_actor_mut().inbox = inbox;
+        self
+    }
+
     fn outbox<'a>(&'a self) -> &'a XsdAnyUri
     where
         Inner: 'a,
@@ -34,6 +38,11 @@ pub trait ApActorRefExt<Inner>: ApActorRef<Inner> {
         &self.ap_actor_ref().outbox
     }
 
+    fn set_outbox(&mut self, outbox: XsdAnyUri) -> &mut Self {
+        self.ap_actor_mut().outbox = outbox;
+        self
+    }
+
     fn following<'a>(&'a self) -> Option<&'a XsdAnyUri>
     where
         Inner: 'a,
@@ -41,53 +50,6 @@ pub trait ApActorRefExt<Inner>: ApActorRef<Inner> {
         self.ap_actor_ref().following.as_ref()
     }
 
-    fn followers<'a>(&'a self) -> Option<&'a XsdAnyUri>
-    where
-        Inner: 'a,
-    {
-        self.ap_actor_ref().followers.as_ref()
-    }
-
-    fn liked<'a>(&'a self) -> Option<&'a XsdAnyUri>
-    where
-        Inner: 'a,
-    {
-        self.ap_actor_ref().liked.as_ref()
-    }
-
-    fn streams<'a>(&'a self) -> Option<&'a OneOrMany<XsdAnyUri>>
-    where
-        Inner: 'a,
-    {
-        self.ap_actor_ref().streams.as_ref()
-    }
-
-    fn preferred_username<'a>(&'a self) -> Option<&'a XsdString>
-    where
-        Inner: 'a,
-    {
-        self.ap_actor_ref().preferred_username.as_ref()
-    }
-
-    fn endpoints<'a>(&'a self) -> Option<&'a Endpoints>
-    where
-        Inner: 'a,
-    {
-        self.ap_actor_ref().endpoints.as_ref()
-    }
-}
-
-pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
-    fn set_inbox(&mut self, inbox: XsdAnyUri) -> &mut Self {
-        self.ap_actor_mut().inbox = inbox;
-        self
-    }
-
-    fn set_outbox(&mut self, outbox: XsdAnyUri) -> &mut Self {
-        self.ap_actor_mut().outbox = outbox;
-        self
-    }
-
     fn set_following(&mut self, following: XsdAnyUri) -> &mut Self {
         self.ap_actor_mut().following = Some(following);
         self
@@ -102,6 +64,13 @@ pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
         self
     }
 
+    fn followers<'a>(&'a self) -> Option<&'a XsdAnyUri>
+    where
+        Inner: 'a,
+    {
+        self.ap_actor_ref().followers.as_ref()
+    }
+
     fn set_followers(&mut self, followers: XsdAnyUri) -> &mut Self {
         self.ap_actor_mut().followers = Some(followers);
         self
@@ -116,6 +85,13 @@ pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
         self
     }
 
+    fn liked<'a>(&'a self) -> Option<&'a XsdAnyUri>
+    where
+        Inner: 'a,
+    {
+        self.ap_actor_ref().liked.as_ref()
+    }
+
     fn set_liked(&mut self, liked: XsdAnyUri) -> &mut Self {
         self.ap_actor_mut().liked = Some(liked);
         self
@@ -125,11 +101,18 @@ pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
         self.ap_actor_mut().liked.take()
     }
 
-    fn delete_likes(&mut self) -> &mut Self {
+    fn delete_liked(&mut self) -> &mut Self {
         self.ap_actor_mut().liked = None;
         self
     }
 
+    fn streams<'a>(&'a self) -> Option<&'a OneOrMany<XsdAnyUri>>
+    where
+        Inner: 'a,
+    {
+        self.ap_actor_ref().streams.as_ref()
+    }
+
     fn set_streams(&mut self, streams: XsdAnyUri) -> &mut Self {
         self.ap_actor_mut().streams = Some(streams.into());
         self
@@ -165,6 +148,13 @@ pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
         self
     }
 
+    fn preferred_username<'a>(&'a self) -> Option<&'a XsdString>
+    where
+        Inner: 'a,
+    {
+        self.ap_actor_ref().preferred_username.as_ref()
+    }
+
     fn set_preferred_username(&mut self, string: XsdString) -> &mut Self {
         self.ap_actor_mut().preferred_username = Some(string);
         self
@@ -179,6 +169,13 @@ pub trait ApActorMutExt<Inner>: ApActorMut<Inner> {
         self
     }
 
+    fn endpoints<'a>(&'a self) -> Option<&'a Endpoints>
+    where
+        Inner: 'a,
+    {
+        self.ap_actor_ref().endpoints.as_ref()
+    }
+
     fn set_endpoints(&mut self, endpoints: Endpoints) -> &mut Self {
         self.ap_actor_mut().endpoints = Some(endpoints);
         self
@@ -266,7 +263,7 @@ pub struct Endpoints {
 impl<Inner> ApActor<Inner> {
     fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
     where
-        Inner: UnparsedMut + traits::Actor,
+        Inner: UnparsedMut + markers::Actor,
     {
         let inbox = inner.remove("inbox")?;
         let outbox = inner.remove("outbox")?;
@@ -292,7 +289,7 @@ impl<Inner> ApActor<Inner> {
 
     fn retracting(self) -> Result<Inner, serde_json::Error>
     where
-        Inner: UnparsedMut + traits::Actor,
+        Inner: UnparsedMut + markers::Actor,
     {
         let ApActor {
             inbox,
@@ -320,28 +317,31 @@ impl<Inner> ApActor<Inner> {
     }
 }
 
-impl traits::Actor for Application {}
-impl traits::Actor for Group {}
-impl traits::Actor for Organization {}
-impl traits::Actor for Person {}
-impl traits::Actor for Service {}
+impl markers::Actor for Application {}
+impl markers::Actor for Group {}
+impl markers::Actor for Organization {}
+impl markers::Actor for Person {}
+impl markers::Actor for Service {}
 
-impl<Inner> traits::Base for ApActor<Inner> where Inner: traits::Base {}
-impl<Inner> traits::Object for ApActor<Inner> where Inner: traits::Object {}
-impl<Inner> traits::Actor for ApActor<Inner> where Inner: traits::Actor {}
+impl<Inner> markers::Base for ApActor<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for ApActor<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Actor for ApActor<Inner> where Inner: markers::Actor {}
 
-impl<Inner> Extends<Inner> for ApActor<Inner>
+impl<Inner, Kind> Extends<Kind> for ApActor<Inner>
 where
-    Inner: UnparsedMut + traits::Actor,
+    Inner: Extends<Kind, Error = serde_json::Error> + UnparsedMut + markers::Actor,
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
 {
     type Error = serde_json::Error;
 
-    fn extends(inner: Inner) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Inner, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -354,39 +354,56 @@ where
     }
 }
 
-impl<Inner, Kind> ObjectRef<Kind> for ApActor<Inner>
+impl<Inner, Kind> AsBase<Kind> for ApActor<Inner>
 where
-    Inner: ObjectRef<Kind>,
+    Inner: AsBase<Kind>,
+{
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner, Kind> AsObject<Kind> for ApActor<Inner>
+where
+    Inner: AsObject<Kind>,
 {
     fn object_ref(&self) -> &Object<Kind> {
         self.inner.object_ref()
     }
-}
-impl<Inner, Kind> ObjectMut<Kind> for ApActor<Inner>
-where
-    Inner: ObjectMut<Kind>,
-{
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Inner> ApActorRef<Inner> for ApActor<Inner>
+impl<Inner> AsApActor<Inner> for ApActor<Inner>
 where
-    Inner: traits::Actor,
+    Inner: markers::Actor,
 {
     fn ap_actor_ref(&self) -> &ApActor<Inner> {
         self
     }
-}
-impl<Inner> ApActorMut<Inner> for ApActor<Inner>
-where
-    Inner: traits::Actor,
-{
+
     fn ap_actor_mut(&mut self) -> &mut ApActor<Inner> {
         self
     }
 }
 
-impl<T, Inner> ApActorRefExt<Inner> for T where T: ApActorRef<Inner> {}
-impl<T, Inner> ApActorMutExt<Inner> for T where T: ApActorMut<Inner> {}
+impl<Inner1, Inner2> AsApObject<Inner2> for ApActor<Inner1>
+where
+    Inner1: AsApObject<Inner2>,
+{
+    fn ap_object_ref(&self) -> &ApObject<Inner2> {
+        self.inner.ap_object_ref()
+    }
+
+    fn ap_object_mut(&mut self) -> &mut ApObject<Inner2> {
+        self.inner.ap_object_mut()
+    }
+}
+
+impl<T, Inner> ApActorExt<Inner> for T where T: AsApActor<Inner> {}
diff --git a/src/base.rs b/src/base.rs
new file mode 100644
index 0000000..1e93bff
--- /dev/null
+++ b/src/base.rs
@@ -0,0 +1,534 @@
+use crate::{
+    either::Either,
+    markers,
+    primitives::{AnyString, MimeMediaType, OneOrMany, XsdAnyUri, XsdString},
+    unparsed::{Unparsed, UnparsedMut},
+};
+use typed_builder::TypedBuilder;
+
+pub trait Extends<Kind>: Sized {
+    type Error: std::error::Error;
+
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error>;
+
+    fn retracts(self) -> Result<Base<Kind>, Self::Error>;
+}
+
+pub trait AsBase<Kind>: markers::Base {
+    fn base_ref(&self) -> &Base<Kind>;
+    fn base_mut(&mut self) -> &mut Base<Kind>;
+}
+
+pub trait BaseExt<Kind>: AsBase<Kind> {
+    fn context<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().context.as_ref()
+    }
+
+    fn set_context<T>(&mut self, context: T) -> &mut Self
+    where
+        T: Into<AnyBase>,
+    {
+        self.base_mut().context = Some(context.into().into());
+        self
+    }
+
+    fn set_many_contexts<I, T>(&mut self, items: I) -> &mut Self
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<AnyBase>,
+    {
+        let v: Vec<_> = items.into_iter().map(Into::into).collect();
+        self.base_mut().context = Some(v.into());
+        self
+    }
+
+    fn add_context<T>(&mut self, context: T) -> &mut Self
+    where
+        T: Into<AnyBase>,
+    {
+        let c = match self.base_mut().context.take() {
+            Some(mut c) => {
+                c.add(context.into());
+                c
+            }
+            None => vec![context.into()].into(),
+        };
+        self.base_mut().context = Some(c);
+        self
+    }
+
+    fn take_context(&mut self) -> Option<OneOrMany<AnyBase>> {
+        self.base_mut().context.take()
+    }
+
+    fn delete_context(&mut self) -> &mut Self {
+        self.base_mut().context = None;
+        self
+    }
+
+    fn id<'a>(&'a self) -> Option<&'a XsdAnyUri>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().id.as_ref()
+    }
+
+    fn set_id(&mut self, id: XsdAnyUri) -> &mut Self {
+        self.base_mut().id = Some(id);
+        self
+    }
+
+    fn take_id(&mut self) -> Option<XsdAnyUri> {
+        self.base_mut().id.take()
+    }
+
+    fn delete_id(&mut self) -> &mut Self {
+        self.base_mut().id = None;
+        self
+    }
+
+    fn kind<'a>(&'a self) -> Option<&'a Kind>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().kind.as_ref()
+    }
+
+    fn set_kind(&mut self, kind: Kind) -> &mut Self {
+        self.base_mut().kind = Some(kind);
+        self
+    }
+
+    fn take_kind(&mut self) -> Option<Kind> {
+        self.base_mut().kind.take()
+    }
+
+    fn delete_kind(&mut self) -> &mut Self {
+        self.base_mut().kind = None;
+        self
+    }
+
+    fn name<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().name.as_ref()
+    }
+
+    fn set_name<T>(&mut self, name: T) -> &mut Self
+    where
+        T: Into<AnyString>,
+    {
+        self.base_mut().name = Some(name.into().into());
+        self
+    }
+
+    fn set_many_names<I, T>(&mut self, items: I) -> &mut Self
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<AnyString>,
+    {
+        let v: Vec<_> = items.into_iter().map(Into::into).collect();
+        self.base_mut().name = Some(v.into());
+        self
+    }
+
+    fn add_name<T>(&mut self, name: T) -> &mut Self
+    where
+        T: Into<AnyString>,
+    {
+        let a = match self.base_mut().name.take() {
+            Some(mut a) => {
+                a.add(name.into());
+                a
+            }
+            None => vec![name.into()].into(),
+        };
+        self.base_mut().name = Some(a);
+        self
+    }
+
+    fn take_name(&mut self) -> Option<OneOrMany<AnyString>> {
+        self.base_mut().name.take()
+    }
+
+    fn delete_name(&mut self) -> &mut Self {
+        self.base_mut().name = None;
+        self
+    }
+
+    fn media_type<'a>(&'a self) -> Option<&'a MimeMediaType>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().media_type.as_ref()
+    }
+
+    fn set_media_type(&mut self, media_type: MimeMediaType) -> &mut Self {
+        self.base_mut().media_type = Some(media_type);
+        self
+    }
+
+    fn take_media_type(&mut self) -> Option<MimeMediaType> {
+        self.base_mut().media_type.take()
+    }
+
+    fn delete_media_type(&mut self) -> &mut Self {
+        self.base_mut().media_type = None;
+        self
+    }
+
+    fn preview<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.base_ref().preview.as_ref()
+    }
+
+    fn set_preview<T>(&mut self, preview: T) -> &mut Self
+    where
+        T: Into<AnyBase>,
+    {
+        self.base_mut().preview = Some(preview.into().into());
+        self
+    }
+
+    fn set_many_previews<I, T>(&mut self, items: I) -> &mut Self
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<AnyBase>,
+    {
+        let v: Vec<_> = items.into_iter().map(Into::into).collect();
+        self.base_mut().preview = Some(v.into());
+        self
+    }
+
+    fn add_preview<T>(&mut self, preview: T) -> &mut Self
+    where
+        T: Into<AnyBase>,
+    {
+        let a = match self.base_mut().preview.take() {
+            Some(mut a) => {
+                a.add(preview.into());
+                a
+            }
+            None => vec![preview.into()].into(),
+        };
+        self.base_mut().preview = Some(a);
+        self
+    }
+
+    fn take_preview(&mut self) -> Option<OneOrMany<AnyBase>> {
+        self.base_mut().preview.take()
+    }
+
+    fn delete_preview(&mut self) -> &mut Self {
+        self.base_mut().preview = None;
+        self
+    }
+}
+
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[serde(transparent)]
+struct IdOrBase(Either<XsdAnyUri, Box<Base<serde_json::Value>>>);
+
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[serde(transparent)]
+pub struct AnyBase(Either<IdOrBase, XsdString>);
+
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
+#[builder(doc)]
+pub struct Base<Kind> {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    pub context: Option<OneOrMany<AnyBase>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    pub id: Option<XsdAnyUri>,
+
+    #[serde(rename = "type")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
+    pub kind: Option<Kind>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    pub name: Option<OneOrMany<AnyString>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
+    pub media_type: Option<MimeMediaType>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    pub preview: Option<OneOrMany<AnyBase>>,
+
+    #[serde(flatten)]
+    #[builder(default)]
+    pub unparsed: Unparsed,
+}
+
+impl Base<serde_json::Value> {
+    pub fn solidify<Kind>(self) -> Result<Base<Kind>, serde_json::Error>
+    where
+        Kind: serde::de::DeserializeOwned,
+    {
+        self.try_map_kind(serde_json::from_value)
+    }
+}
+
+impl<Kind> Base<Kind> {
+    pub fn extend<T>(self) -> Result<T, T::Error>
+    where
+        T: Extends<Kind>,
+    {
+        T::extends(self)
+    }
+
+    pub fn retract<T>(t: T) -> Result<Self, T::Error>
+    where
+        T: Extends<Kind>,
+    {
+        t.retracts()
+    }
+
+    pub fn into_generic(self) -> Result<Base<serde_json::Value>, serde_json::Error>
+    where
+        Kind: serde::ser::Serialize,
+    {
+        self.try_map_kind(serde_json::to_value)
+    }
+
+    pub fn map_kind<NewKind>(self, f: impl Fn(Kind) -> NewKind) -> Base<NewKind> {
+        Base {
+            kind: self.kind.map(f),
+            context: self.context,
+            id: self.id,
+            name: self.name,
+            media_type: self.media_type,
+            preview: self.preview,
+            unparsed: self.unparsed,
+        }
+    }
+
+    pub fn try_map_kind<NewKind, E>(
+        self,
+        f: impl Fn(Kind) -> Result<NewKind, E>,
+    ) -> Result<Base<NewKind>, E> {
+        Ok(Base {
+            kind: if let Some(kind) = self.kind {
+                Some((f)(kind)?)
+            } else {
+                None
+            },
+            context: self.context,
+            id: self.id,
+            name: self.name,
+            media_type: self.media_type,
+            preview: self.preview,
+            unparsed: self.unparsed,
+        })
+    }
+}
+
+impl AnyBase {
+    pub fn as_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
+        self.0.as_ref().left().and_then(|l| l.as_xsd_any_uri())
+    }
+
+    pub fn as_xsd_string(&self) -> Option<&XsdString> {
+        self.0.as_ref().right()
+    }
+
+    pub fn as_base(&self) -> Option<&Base<serde_json::Value>> {
+        self.0.as_ref().left().and_then(|l| l.as_base())
+    }
+
+    pub fn id(self) -> Option<XsdAnyUri> {
+        self.0.left().and_then(|l| l.id())
+    }
+
+    pub fn xsd_string(self) -> Option<XsdString> {
+        self.0.right()
+    }
+
+    pub fn base(self) -> Option<Base<serde_json::Value>> {
+        self.0.left().and_then(|l| l.base())
+    }
+
+    pub fn set_xsd_any_uri(&mut self, id: XsdAnyUri) {
+        self.0 = Either::Left(IdOrBase::from_xsd_any_uri(id));
+    }
+
+    pub fn set_base(&mut self, base: Base<serde_json::Value>) {
+        self.0 = Either::Left(IdOrBase::from_base(base));
+    }
+
+    pub fn set_xsd_string(&mut self, xsd_string: XsdString) {
+        self.0 = Either::Right(xsd_string);
+    }
+
+    pub fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
+        AnyBase(Either::Left(IdOrBase::from_xsd_any_uri(id)))
+    }
+
+    pub fn from_base(base: Base<serde_json::Value>) -> Self {
+        AnyBase(Either::Left(IdOrBase::from_base(base)))
+    }
+
+    pub fn from_xsd_string(xsd_string: XsdString) -> Self {
+        AnyBase(Either::Right(xsd_string))
+    }
+}
+
+impl IdOrBase {
+    fn as_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
+        self.0.as_ref().left()
+    }
+
+    fn as_base(&self) -> Option<&Base<serde_json::Value>> {
+        self.0.as_ref().right().map(|b| b.as_ref())
+    }
+
+    fn id(self) -> Option<XsdAnyUri> {
+        self.0.left()
+    }
+
+    fn base(self) -> Option<Base<serde_json::Value>> {
+        self.0.right().map(|b| *b)
+    }
+
+    fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
+        IdOrBase(Either::Left(id))
+    }
+
+    fn from_base(base: Base<serde_json::Value>) -> Self {
+        IdOrBase(Either::Right(Box::new(base)))
+    }
+}
+
+impl OneOrMany<AnyBase> {
+    pub fn as_single_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
+        self.as_one().and_then(|inner| inner.as_xsd_any_uri())
+    }
+
+    pub fn as_single_xsd_string(&self) -> Option<&XsdString> {
+        self.as_one().and_then(|inner| inner.as_xsd_string())
+    }
+
+    pub fn as_single_base(&self) -> Option<&Base<serde_json::Value>> {
+        self.as_one().and_then(|inner| inner.as_base())
+    }
+
+    pub fn single_xsd_any_uri(self) -> Option<XsdAnyUri> {
+        self.one().and_then(|inner| inner.id())
+    }
+
+    pub fn single_xsd_string(self) -> Option<XsdString> {
+        self.one().and_then(|inner| inner.xsd_string())
+    }
+
+    pub fn single_base(self) -> Option<Base<serde_json::Value>> {
+        self.one().and_then(|inner| inner.base())
+    }
+
+    pub fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
+        OneOrMany(Either::Left(AnyBase::from_xsd_any_uri(id)))
+    }
+
+    pub fn from_xsd_string(xsd_string: XsdString) -> Self {
+        OneOrMany(Either::Left(AnyBase::from_xsd_string(xsd_string)))
+    }
+
+    pub fn from_base(base: Base<serde_json::Value>) -> Self {
+        OneOrMany(Either::Left(AnyBase::from_base(base)))
+    }
+
+    pub fn set_single_xsd_any_uri(&mut self, id: XsdAnyUri) -> &mut Self {
+        self.0 = Either::Left(AnyBase::from_xsd_any_uri(id));
+        self
+    }
+
+    pub fn set_single_xsd_string(&mut self, xsd_string: XsdString) -> &mut Self {
+        self.0 = Either::Left(AnyBase::from_xsd_string(xsd_string));
+        self
+    }
+
+    pub fn set_single_base(&mut self, base: Base<serde_json::Value>) -> &mut Self {
+        self.0 = Either::Left(AnyBase::from_base(base));
+        self
+    }
+
+    pub fn add_xsd_any_uri(&mut self, id: XsdAnyUri) -> &mut Self {
+        self.add(AnyBase::from_xsd_any_uri(id))
+    }
+
+    pub fn add_xsd_string(&mut self, xsd_string: XsdString) -> &mut Self {
+        self.add(AnyBase::from_xsd_string(xsd_string))
+    }
+
+    pub fn add_base(&mut self, base: Base<serde_json::Value>) -> &mut Self {
+        self.add(AnyBase::from_base(base))
+    }
+}
+
+impl<Kind> markers::Base for Base<Kind> {}
+
+impl<Kind> UnparsedMut for Base<Kind> {
+    fn unparsed_mut(&mut self) -> &mut Unparsed {
+        &mut self.unparsed
+    }
+}
+
+impl<Kind> AsBase<Kind> for Base<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self
+    }
+}
+
+impl<T, Kind> BaseExt<Kind> for T where T: AsBase<Kind> {}
+
+impl From<Base<serde_json::Value>> for AnyBase {
+    fn from(o: Base<serde_json::Value>) -> Self {
+        Self::from_base(o)
+    }
+}
+
+impl From<XsdAnyUri> for AnyBase {
+    fn from(id: XsdAnyUri) -> Self {
+        Self::from_xsd_any_uri(id)
+    }
+}
+
+impl From<XsdString> for AnyBase {
+    fn from(xsd_string: XsdString) -> Self {
+        Self::from_xsd_string(xsd_string)
+    }
+}
+
+impl From<Base<serde_json::Value>> for OneOrMany<AnyBase> {
+    fn from(object: Base<serde_json::Value>) -> Self {
+        Self::from_base(object)
+    }
+}
+
+impl From<XsdAnyUri> for OneOrMany<AnyBase> {
+    fn from(xsd_any_uri: XsdAnyUri) -> Self {
+        Self::from_xsd_any_uri(xsd_any_uri)
+    }
+}
+
+impl From<XsdString> for OneOrMany<AnyBase> {
+    fn from(xsd_string: XsdString) -> Self {
+        Self::from_xsd_string(xsd_string)
+    }
+}
diff --git a/src/collection.rs b/src/collection.rs
index 8e009c8..8b04489 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -1,7 +1,9 @@
 use crate::{
-    object::{AnyObject, ApObject, Object, ObjectMut, ObjectRef},
-    primitives::{OneOrMany, Unparsed, XsdNonNegativeInteger},
-    traits::{self, Extends, UnparsedMut, UnparsedMutExt},
+    base::{AnyBase, AsBase, Base, Extends},
+    markers,
+    object::{ApObject, AsObject, Object},
+    primitives::{OneOrMany, XsdNonNegativeInteger},
+    unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
 };
 use std::convert::TryFrom;
 use typed_builder::TypedBuilder;
@@ -12,71 +14,32 @@ pub mod kind {
 
 use self::kind::*;
 
-pub trait CollectionRef<Kind>: traits::Collection {
+pub trait AsCollection<Kind>: markers::Collection {
     fn collection_ref(&self) -> &Collection<Kind>;
-}
-
-pub trait CollectionMut<Kind>: traits::Collection {
     fn collection_mut(&mut self) -> &mut Collection<Kind>;
 }
 
-pub trait CollectionPageRef<Kind>: traits::CollectionPage {
+pub trait AsCollectionPage<Kind>: markers::CollectionPage {
     fn collection_page_ref(&self) -> &CollectionPage<Kind>;
-}
-
-pub trait CollectionPageMut<Kind>: traits::CollectionPage {
     fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind>;
 }
 
-pub trait OrderedCollectionPageRef: traits::CollectionPage {
+pub trait AsOrderedCollectionPage: markers::CollectionPage {
     fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage;
-}
-
-pub trait OrderedCollectionPageMut: traits::CollectionPage {
     fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage;
 }
 
-pub trait CollectionRefExt<Kind>: CollectionRef<Kind> {
-    fn items<'a>(&'a self) -> &'a OneOrMany<AnyObject>
+pub trait CollectionExt<Kind>: AsCollection<Kind> {
+    fn items<'a>(&'a self) -> &'a OneOrMany<AnyBase>
     where
         Kind: 'a,
     {
         &self.collection_ref().items
     }
 
-    fn total_items<'a>(&'a self) -> Option<&'a XsdNonNegativeInteger>
-    where
-        Kind: 'a,
-    {
-        self.collection_ref().total_items.as_ref()
-    }
-
-    fn current<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Kind: 'a,
-    {
-        self.collection_ref().current.as_ref()
-    }
-
-    fn first<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Kind: 'a,
-    {
-        self.collection_ref().first.as_ref()
-    }
-
-    fn last<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Kind: 'a,
-    {
-        self.collection_ref().last.as_ref()
-    }
-}
-
-pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
     fn set_items<T>(&mut self, item: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_mut().items = item.into().into();
         self
@@ -85,7 +48,7 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
     fn set_many_items<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.collection_mut().items = v.into();
@@ -94,12 +57,19 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
 
     fn add_item<T>(&mut self, item: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_mut().items.add(item.into());
         self
     }
 
+    fn total_items<'a>(&'a self) -> Option<&'a XsdNonNegativeInteger>
+    where
+        Kind: 'a,
+    {
+        self.collection_ref().total_items.as_ref()
+    }
+
     fn set_total_items<T>(&mut self, total_items: T) -> &mut Self
     where
         T: Into<XsdNonNegativeInteger>,
@@ -117,15 +87,22 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
         self
     }
 
+    fn current<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Kind: 'a,
+    {
+        self.collection_ref().current.as_ref()
+    }
+
     fn set_current<T>(&mut self, current: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_mut().current = Some(current.into());
         self
     }
 
-    fn take_current(&mut self) -> Option<AnyObject> {
+    fn take_current(&mut self) -> Option<AnyBase> {
         self.collection_mut().current.take()
     }
 
@@ -134,15 +111,22 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
         self
     }
 
+    fn first<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Kind: 'a,
+    {
+        self.collection_ref().first.as_ref()
+    }
+
     fn set_first<T>(&mut self, first: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_mut().first = Some(first.into());
         self
     }
 
-    fn take_first(&mut self) -> Option<AnyObject> {
+    fn take_first(&mut self) -> Option<AnyBase> {
         self.collection_mut().first.take()
     }
 
@@ -151,15 +135,22 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
         self
     }
 
+    fn last<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Kind: 'a,
+    {
+        self.collection_ref().last.as_ref()
+    }
+
     fn set_last<T>(&mut self, last: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_mut().last = Some(last.into());
         self
     }
 
-    fn take_last(&mut self) -> Option<AnyObject> {
+    fn take_last(&mut self) -> Option<AnyBase> {
         self.collection_mut().last.take()
     }
 
@@ -169,39 +160,23 @@ pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
     }
 }
 
-pub trait CollectionPageRefExt<Kind>: CollectionPageRef<Kind> {
-    fn part_of<'a>(&'a self) -> Option<&'a AnyObject>
+pub trait CollectionPageExt<Kind>: AsCollectionPage<Kind> {
+    fn part_of<'a>(&'a self) -> Option<&'a AnyBase>
     where
         Kind: 'a,
     {
         self.collection_page_ref().part_of.as_ref()
     }
 
-    fn next<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Kind: 'a,
-    {
-        self.collection_page_ref().next.as_ref()
-    }
-
-    fn prev<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Kind: 'a,
-    {
-        self.collection_page_ref().prev.as_ref()
-    }
-}
-
-pub trait CollectionPageMutExt<Kind>: CollectionPageMut<Kind> {
     fn set_part_of<T>(&mut self, part_of: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_page_mut().part_of = Some(part_of.into());
         self
     }
 
-    fn take_part_of(&mut self) -> Option<AnyObject> {
+    fn take_part_of(&mut self) -> Option<AnyBase> {
         self.collection_page_mut().part_of.take()
     }
 
@@ -210,15 +185,22 @@ pub trait CollectionPageMutExt<Kind>: CollectionPageMut<Kind> {
         self
     }
 
+    fn next<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Kind: 'a,
+    {
+        self.collection_page_ref().next.as_ref()
+    }
+
     fn set_next<T>(&mut self, next: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_page_mut().next = Some(next.into());
         self
     }
 
-    fn take_next(&mut self) -> Option<AnyObject> {
+    fn take_next(&mut self) -> Option<AnyBase> {
         self.collection_page_mut().next.take()
     }
 
@@ -227,15 +209,22 @@ pub trait CollectionPageMutExt<Kind>: CollectionPageMut<Kind> {
         self
     }
 
+    fn prev<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Kind: 'a,
+    {
+        self.collection_page_ref().prev.as_ref()
+    }
+
     fn set_prev<T>(&mut self, prev: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.collection_page_mut().prev = Some(prev.into());
         self
     }
 
-    fn take_prev(&mut self) -> Option<AnyObject> {
+    fn take_prev(&mut self) -> Option<AnyBase> {
         self.collection_page_mut().prev.take()
     }
 
@@ -245,13 +234,11 @@ pub trait CollectionPageMutExt<Kind>: CollectionPageMut<Kind> {
     }
 }
 
-pub trait OrderedCollectionPageRefExt: OrderedCollectionPageRef {
+pub trait OrderedCollectionPageExt: AsOrderedCollectionPage {
     fn start_index(&self) -> Option<&XsdNonNegativeInteger> {
         self.ordered_collection_page_ref().start_index.as_ref()
     }
-}
 
-pub trait OrderedCollectionPageMutExt: OrderedCollectionPageMut {
     fn set_start_index<T>(&mut self, start_index: T) -> &mut Self
     where
         T: Into<XsdNonNegativeInteger>,
@@ -279,7 +266,7 @@ pub type UnorderedCollectionPage = CollectionPage<CollectionPageType>;
 #[builder(doc)]
 pub struct Collection<Kind> {
     #[builder(setter(into))]
-    pub items: OneOrMany<AnyObject>,
+    pub items: OneOrMany<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
@@ -287,15 +274,15 @@ pub struct Collection<Kind> {
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub current: Option<AnyObject>,
+    pub current: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub first: Option<AnyObject>,
+    pub first: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub last: Option<AnyObject>,
+    pub last: Option<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Object<Kind>,
@@ -307,15 +294,15 @@ pub struct Collection<Kind> {
 pub struct CollectionPage<Kind> {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub part_of: Option<AnyObject>,
+    pub part_of: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub next: Option<AnyObject>,
+    pub next: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub prev: Option<AnyObject>,
+    pub prev: Option<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Collection<Kind>,
@@ -426,29 +413,34 @@ impl OrderedCollectionPage {
     }
 }
 
-impl<Kind> traits::Base for Collection<Kind> {}
-impl<Kind> traits::Object for Collection<Kind> {}
-impl<Kind> traits::Collection for Collection<Kind> {}
+impl<Kind> markers::Base for Collection<Kind> {}
+impl<Kind> markers::Object for Collection<Kind> {}
+impl<Kind> markers::Collection for Collection<Kind> {}
 
-impl<Kind> traits::Base for CollectionPage<Kind> {}
-impl<Kind> traits::Object for CollectionPage<Kind> {}
-impl<Kind> traits::Collection for CollectionPage<Kind> {}
-impl<Kind> traits::CollectionPage for CollectionPage<Kind> {}
+impl<Kind> markers::Base for CollectionPage<Kind> {}
+impl<Kind> markers::Object for CollectionPage<Kind> {}
+impl<Kind> markers::Collection for CollectionPage<Kind> {}
+impl<Kind> markers::CollectionPage for CollectionPage<Kind> {}
 
-impl traits::Base for OrderedCollectionPage {}
-impl traits::Object for OrderedCollectionPage {}
-impl traits::Collection for OrderedCollectionPage {}
-impl traits::CollectionPage for OrderedCollectionPage {}
+impl markers::Base for OrderedCollectionPage {}
+impl markers::Object for OrderedCollectionPage {}
+impl markers::Collection for OrderedCollectionPage {}
+impl markers::CollectionPage for OrderedCollectionPage {}
 
-impl<Kind> Extends<Object<Kind>> for Collection<Kind> {
+impl<Kind> Extends<Kind> for Collection<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -468,15 +460,20 @@ impl<Kind> TryFrom<Object<Kind>> for Collection<Kind> {
     }
 }
 
-impl<Kind> Extends<Object<Kind>> for CollectionPage<Kind> {
+impl<Kind> Extends<Kind> for CollectionPage<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
     type Error = serde_json::Error;
 
-    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -496,15 +493,17 @@ impl<Kind> TryFrom<CollectionPage<Kind>> for Object<Kind> {
     }
 }
 
-impl Extends<Object<OrderedCollectionPageType>> for OrderedCollectionPage {
+impl Extends<OrderedCollectionPageType> for OrderedCollectionPage {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<OrderedCollectionPageType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<OrderedCollectionPageType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<OrderedCollectionPageType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<OrderedCollectionPageType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -542,153 +541,158 @@ impl UnparsedMut for OrderedCollectionPage {
     }
 }
 
-impl<Kind> ObjectRef<Kind> for Collection<Kind> {
+impl<Kind> AsBase<Kind> for Collection<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Kind> AsObject<Kind> for Collection<Kind> {
     fn object_ref(&self) -> &Object<Kind> {
         &self.inner
     }
-}
-impl<Kind> ObjectMut<Kind> for Collection<Kind> {
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> CollectionRef<Kind> for Collection<Kind> {
+impl<Kind> AsCollection<Kind> for Collection<Kind> {
     fn collection_ref(&self) -> &Collection<Kind> {
         self
     }
-}
-impl<Kind> CollectionMut<Kind> for Collection<Kind> {
+
     fn collection_mut(&mut self) -> &mut Collection<Kind> {
         self
     }
 }
 
-impl<Kind> ObjectRef<Kind> for CollectionPage<Kind> {
+impl<Kind> AsBase<Kind> for CollectionPage<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Kind> AsObject<Kind> for CollectionPage<Kind> {
     fn object_ref(&self) -> &Object<Kind> {
         self.inner.object_ref()
     }
-}
-impl<Kind> ObjectMut<Kind> for CollectionPage<Kind> {
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> CollectionRef<Kind> for CollectionPage<Kind> {
+impl<Kind> AsCollection<Kind> for CollectionPage<Kind> {
     fn collection_ref(&self) -> &Collection<Kind> {
         &self.inner
     }
-}
-impl<Kind> CollectionMut<Kind> for CollectionPage<Kind> {
+
     fn collection_mut(&mut self) -> &mut Collection<Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> CollectionPageRef<Kind> for CollectionPage<Kind> {
+impl<Kind> AsCollectionPage<Kind> for CollectionPage<Kind> {
     fn collection_page_ref(&self) -> &CollectionPage<Kind> {
         self
     }
-}
-impl<Kind> CollectionPageMut<Kind> for CollectionPage<Kind> {
+
     fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
         self
     }
 }
 
-impl ObjectRef<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsBase<OrderedCollectionPageType> for OrderedCollectionPage {
+    fn base_ref(&self) -> &Base<OrderedCollectionPageType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<OrderedCollectionPageType> {
+        self.inner.base_mut()
+    }
+}
+
+impl AsObject<OrderedCollectionPageType> for OrderedCollectionPage {
     fn object_ref(&self) -> &Object<OrderedCollectionPageType> {
         self.inner.object_ref()
     }
-}
-impl ObjectMut<OrderedCollectionPageType> for OrderedCollectionPage {
+
     fn object_mut(&mut self) -> &mut Object<OrderedCollectionPageType> {
         self.inner.object_mut()
     }
 }
 
-impl CollectionRef<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsCollection<OrderedCollectionPageType> for OrderedCollectionPage {
     fn collection_ref(&self) -> &Collection<OrderedCollectionPageType> {
         self.inner.collection_ref()
     }
-}
-impl CollectionMut<OrderedCollectionPageType> for OrderedCollectionPage {
+
     fn collection_mut(&mut self) -> &mut Collection<OrderedCollectionPageType> {
         self.inner.collection_mut()
     }
 }
 
-impl CollectionPageRef<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsCollectionPage<OrderedCollectionPageType> for OrderedCollectionPage {
     fn collection_page_ref(&self) -> &CollectionPage<OrderedCollectionPageType> {
         &self.inner
     }
-}
-impl CollectionPageMut<OrderedCollectionPageType> for OrderedCollectionPage {
+
     fn collection_page_mut(&mut self) -> &mut CollectionPage<OrderedCollectionPageType> {
         &mut self.inner
     }
 }
 
-impl<Inner> traits::Collection for ApObject<Inner> where Inner: traits::Collection {}
-impl<Inner> traits::CollectionPage for ApObject<Inner> where Inner: traits::CollectionPage {}
+impl<Inner> markers::Collection for ApObject<Inner> where Inner: markers::Collection {}
+impl<Inner> markers::CollectionPage for ApObject<Inner> where Inner: markers::CollectionPage {}
 
-impl<Inner, Kind> CollectionRef<Kind> for ApObject<Inner>
+impl<Inner, Kind> AsCollection<Kind> for ApObject<Inner>
 where
-    Inner: CollectionRef<Kind>,
+    Inner: AsCollection<Kind>,
 {
     fn collection_ref(&self) -> &Collection<Kind> {
         self.inner.collection_ref()
     }
-}
-impl<Inner, Kind> CollectionMut<Kind> for ApObject<Inner>
-where
-    Inner: CollectionMut<Kind>,
-{
+
     fn collection_mut(&mut self) -> &mut Collection<Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, Kind> CollectionPageRef<Kind> for ApObject<Inner>
+impl<Inner, Kind> AsCollectionPage<Kind> for ApObject<Inner>
 where
-    Inner: CollectionPageRef<Kind>,
+    Inner: AsCollectionPage<Kind>,
 {
     fn collection_page_ref(&self) -> &CollectionPage<Kind> {
         self.inner.collection_page_ref()
     }
-}
-impl<Inner, Kind> CollectionPageMut<Kind> for ApObject<Inner>
-where
-    Inner: CollectionPageMut<Kind>,
-{
+
     fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
         self.inner.collection_page_mut()
     }
 }
 
-impl<Inner> OrderedCollectionPageRef for ApObject<Inner>
+impl<Inner> AsOrderedCollectionPage for ApObject<Inner>
 where
-    Inner: OrderedCollectionPageRef,
+    Inner: AsOrderedCollectionPage,
 {
     fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage {
         self.inner.ordered_collection_page_ref()
     }
-}
-impl<Inner> OrderedCollectionPageMut for ApObject<Inner>
-where
-    Inner: OrderedCollectionPageMut,
-{
+
     fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage {
         self.inner.ordered_collection_page_mut()
     }
 }
 
-impl<T, Kind> CollectionRefExt<Kind> for T where T: CollectionRef<Kind> {}
-impl<T, Kind> CollectionMutExt<Kind> for T where T: CollectionMut<Kind> {}
-
-impl<T, Kind> CollectionPageRefExt<Kind> for T where T: CollectionPageRef<Kind> {}
-impl<T, Kind> CollectionPageMutExt<Kind> for T where T: CollectionPageMut<Kind> {}
-
-impl<T> OrderedCollectionPageRefExt for T where T: OrderedCollectionPageRef {}
-impl<T> OrderedCollectionPageMutExt for T where T: OrderedCollectionPageMut {}
+impl<T, Kind> CollectionExt<Kind> for T where T: AsCollection<Kind> {}
+impl<T, Kind> CollectionPageExt<Kind> for T where T: AsCollectionPage<Kind> {}
+impl<T> OrderedCollectionPageExt for T where T: AsOrderedCollectionPage {}
diff --git a/src/lib.rs b/src/lib.rs
index acf94b1..003886a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,29 +1,31 @@
 pub mod activity;
 pub mod actor;
+pub mod base;
 pub mod collection;
 pub mod either;
+pub mod link;
 pub mod object;
 pub mod primitives;
-pub mod traits;
+pub mod unparsed;
 
 pub use activitystreams::{context, public, security};
 
+pub mod markers {
+    pub use activitystreams::{
+        Activity, Actor, Base, Collection, CollectionPage, IntransitiveActivity, Link, Object,
+    };
+}
+
 pub mod prelude {
     pub use crate::{
         activity::{
-            ActivityMutExt, ActivityRefExt, ActorAndObjectMutExt, ActorAndObjectRefExt,
-            OptOriginMutExt, OptOriginRefExt, OptTargetMutExt, OptTargetRefExt, OriginMutExt,
-            OriginRefExt, QuestionMutExt, QuestionRefExt, TargetMutExt, TargetRefExt,
-        },
-        actor::{ApActorMutExt, ApActorRefExt},
-        collection::{
-            CollectionMutExt, CollectionPageMutExt, CollectionPageRefExt, CollectionRefExt,
-            OrderedCollectionPageMutExt, OrderedCollectionPageRefExt,
-        },
-        object::{
-            ApObjectMutExt, ApObjectRefExt, ObjectMutExt, ObjectRefExt, PlaceRefExt, ProfileMutExt,
-            ProfileRefExt, RelationshipMutExt, RelationshipRefExt, TombstoneMutExt,
-            TombstoneRefExt,
+            ActivityExt, ActorAndObjectRefExt, OptOriginRefExt, OptTargetRefExt, OriginRefExt,
+            QuestionExt, TargetRefExt,
         },
+        actor::ApActorExt,
+        base::BaseExt,
+        collection::{CollectionExt, CollectionPageExt, OrderedCollectionPageExt},
+        link::LinkExt,
+        object::{ApObjectExt, ObjectExt, PlaceExt, ProfileExt, RelationshipExt, TombstoneExt},
     };
 }
diff --git a/src/link.rs b/src/link.rs
new file mode 100644
index 0000000..4974a1f
--- /dev/null
+++ b/src/link.rs
@@ -0,0 +1,284 @@
+use crate::{
+    base::{AsBase, Base, Extends},
+    markers,
+    primitives::{OneOrMany, XsdAnyUri, XsdNonNegativeInteger, XsdString},
+    unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
+};
+use std::convert::TryFrom;
+use typed_builder::TypedBuilder;
+
+pub mod kind {
+    pub use activitystreams::link::kind::MentionType;
+}
+
+use self::kind::MentionType;
+
+pub trait AsLink<Kind>: markers::Link {
+    fn link_ref(&self) -> &Link<Kind>;
+    fn link_mut(&mut self) -> &mut Link<Kind>;
+}
+
+pub trait LinkExt<Kind>: AsLink<Kind> {
+    fn href<'a>(&'a self) -> Option<&'a XsdAnyUri>
+    where
+        Kind: 'a,
+    {
+        self.link_ref().href.as_ref()
+    }
+
+    fn set_href(&mut self, href: XsdAnyUri) -> &mut Self {
+        self.link_mut().href = Some(href);
+        self
+    }
+
+    fn take_href(&mut self) -> Option<XsdAnyUri> {
+        self.link_mut().href.take()
+    }
+
+    fn delete_href(&mut self) -> &mut Self {
+        self.link_mut().href = None;
+        self
+    }
+
+    fn hreflang<'a>(&'a self) -> Option<&'a XsdString>
+    where
+        Kind: 'a,
+    {
+        self.link_ref().hreflang.as_ref()
+    }
+
+    fn set_hreflang(&mut self, hreflang: XsdString) -> &mut Self {
+        self.link_mut().hreflang = Some(hreflang);
+        self
+    }
+
+    fn take_hreflang(&mut self) -> Option<XsdString> {
+        self.link_mut().hreflang.take()
+    }
+
+    fn delete_hreflang(&mut self) -> &mut Self {
+        self.link_mut().hreflang = None;
+        self
+    }
+
+    fn rel<'a>(&'a self) -> Option<&'a OneOrMany<XsdString>>
+    where
+        Kind: 'a,
+    {
+        self.link_ref().rel.as_ref()
+    }
+
+    fn set_rel(&mut self, rel: XsdString) -> &mut Self {
+        self.link_mut().rel = Some(rel.into());
+        self
+    }
+
+    fn set_many_rels<I>(&mut self, items: I) -> &mut Self
+    where
+        I: IntoIterator<Item = XsdString>,
+    {
+        let v: Vec<_> = items.into_iter().collect();
+        self.link_mut().rel = Some(v.into());
+        self
+    }
+
+    fn add_rel(&mut self, rel: XsdString) -> &mut Self {
+        let v = match self.link_mut().rel.take() {
+            Some(mut v) => {
+                v.add(rel);
+                v
+            }
+            None => vec![rel].into(),
+        };
+        self.link_mut().rel = Some(v);
+        self
+    }
+
+    fn take_rel(&mut self) -> Option<OneOrMany<XsdString>> {
+        self.link_mut().rel.take()
+    }
+
+    fn delete_rel(&mut self) -> &mut Self {
+        self.link_mut().rel = None;
+        self
+    }
+
+    fn height<'a>(&'a self) -> Option<&'a XsdNonNegativeInteger>
+    where
+        Kind: 'a,
+    {
+        self.link_ref().height.as_ref()
+    }
+
+    fn set_height<T>(&mut self, height: T) -> &mut Self
+    where
+        T: Into<XsdNonNegativeInteger>,
+    {
+        self.link_mut().height = Some(height.into());
+        self
+    }
+
+    fn take_height(&mut self) -> Option<XsdNonNegativeInteger> {
+        self.link_mut().height.take()
+    }
+
+    fn delete_height(&mut self) -> &mut Self {
+        self.link_mut().height = None;
+        self
+    }
+
+    fn width<'a>(&'a self) -> Option<&'a XsdNonNegativeInteger>
+    where
+        Kind: 'a,
+    {
+        self.link_ref().width.as_ref()
+    }
+
+    fn set_width<T>(&mut self, width: T) -> &mut Self
+    where
+        T: Into<XsdNonNegativeInteger>,
+    {
+        self.link_mut().width = Some(width.into());
+        self
+    }
+
+    fn take_width(&mut self) -> Option<XsdNonNegativeInteger> {
+        self.link_mut().width.take()
+    }
+
+    fn delete_width(&mut self) -> &mut Self {
+        self.link_mut().width = None;
+        self
+    }
+}
+
+pub type Mention = Link<MentionType>;
+
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
+#[builder(doc)]
+pub struct Link<Kind> {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
+    href: Option<XsdAnyUri>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
+    hreflang: Option<XsdString>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    rel: Option<OneOrMany<XsdString>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    height: Option<XsdNonNegativeInteger>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option, into))]
+    width: Option<XsdNonNegativeInteger>,
+
+    #[serde(flatten)]
+    inner: Base<Kind>,
+}
+
+impl<Kind> Link<Kind> {
+    fn extending(mut inner: Base<Kind>) -> Result<Self, serde_json::Error> {
+        Ok(Link {
+            href: inner.remove("href")?,
+            hreflang: inner.remove("hreflang")?,
+            rel: inner.remove("rel")?,
+            height: inner.remove("height")?,
+            width: inner.remove("width")?,
+            inner,
+        })
+    }
+
+    fn retracting(self) -> Result<Base<Kind>, serde_json::Error> {
+        let Link {
+            href,
+            hreflang,
+            rel,
+            height,
+            width,
+            mut inner,
+        } = self;
+
+        inner
+            .insert("href", href)?
+            .insert("hreflang", hreflang)?
+            .insert("rel", rel)?
+            .insert("height", height)?
+            .insert("width", width)?;
+
+        Ok(inner)
+    }
+}
+
+impl<Kind> markers::Base for Link<Kind> {}
+impl<Kind> markers::Link for Link<Kind> {}
+
+impl<Kind> Extends<Kind> for Link<Kind>
+where
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
+{
+    type Error = serde_json::Error;
+
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        Self::extending(base)
+    }
+
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        self.retracting()
+    }
+}
+
+impl<Kind> TryFrom<Base<Kind>> for Link<Kind>
+where
+    Kind: serde::de::DeserializeOwned,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(base: Base<Kind>) -> Result<Self, Self::Error> {
+        Self::extending(base)
+    }
+}
+
+impl<Kind> TryFrom<Link<Kind>> for Base<Kind>
+where
+    Kind: serde::ser::Serialize,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(link: Link<Kind>) -> Result<Self, Self::Error> {
+        link.retracting()
+    }
+}
+
+impl<Kind> UnparsedMut for Link<Kind> {
+    fn unparsed_mut(&mut self) -> &mut Unparsed {
+        self.inner.unparsed_mut()
+    }
+}
+
+impl<Kind> AsBase<Kind> for Link<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        &self.inner
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        &mut self.inner
+    }
+}
+
+impl<Kind> AsLink<Kind> for Link<Kind> {
+    fn link_ref(&self) -> &Link<Kind> {
+        self
+    }
+
+    fn link_mut(&mut self) -> &mut Link<Kind> {
+        self
+    }
+}
+
+impl<T, Kind> LinkExt<Kind> for T where T: AsLink<Kind> {}
diff --git a/src/object.rs b/src/object.rs
index 467abb0..fd5ef14 100644
--- a/src/object.rs
+++ b/src/object.rs
@@ -1,10 +1,8 @@
 use crate::{
-    either::Either,
-    primitives::{
-        AnyString, MimeMediaType, OneOrMany, Unit, Unparsed, XsdAnyUri, XsdDateTime, XsdDuration,
-        XsdFloat, XsdString,
-    },
-    traits::{self, Extends, UnparsedMut, UnparsedMutExt},
+    base::{AnyBase, AsBase, Base, Extends},
+    markers,
+    primitives::{AnyString, OneOrMany, Unit, XsdAnyUri, XsdDateTime, XsdDuration, XsdFloat},
+    unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
 };
 use std::convert::TryFrom;
 use typed_builder::TypedBuilder;
@@ -15,312 +13,47 @@ pub mod kind {
 
 use self::kind::*;
 
-pub trait ObjectRef<Kind>: traits::Object {
+pub trait AsObject<Kind>: markers::Object {
     fn object_ref(&self) -> &Object<Kind>;
-}
-
-pub trait ObjectMut<Kind>: traits::Object {
     fn object_mut(&mut self) -> &mut Object<Kind>;
 }
 
-pub trait ApObjectRef<Inner>: traits::Object {
+pub trait AsApObject<Inner>: markers::Object {
     fn ap_object_ref(&self) -> &ApObject<Inner>;
-}
-
-pub trait ApObjectMut<Inner>: traits::Object {
     fn ap_object_mut(&mut self) -> &mut ApObject<Inner>;
 }
 
-pub trait PlaceRef: traits::Object {
+pub trait AsPlace: markers::Object {
     fn place_ref(&self) -> &Place;
-}
-
-pub trait PlaceMut: traits::Object {
     fn place_mut(&mut self) -> &mut Place;
 }
 
-pub trait ProfileRef: traits::Object {
+pub trait AsProfile: markers::Object {
     fn profile_ref(&self) -> &Profile;
-}
-
-pub trait ProfileMut: traits::Object {
     fn profile_mut(&mut self) -> &mut Profile;
 }
 
-pub trait RelationshipRef: traits::Object {
+pub trait AsRelationship: markers::Object {
     fn relationship_ref(&self) -> &Relationship;
-}
-
-pub trait RelationshipMut: traits::Object {
     fn relationship_mut(&mut self) -> &mut Relationship;
 }
 
-pub trait TombstoneRef: traits::Object {
+pub trait AsTombstone: markers::Object {
     fn tombstone_ref(&self) -> &Tombstone;
-}
-
-pub trait TombstoneMut: traits::Object {
     fn tombstone_mut(&mut self) -> &mut Tombstone;
 }
 
-pub trait ObjectRefExt<Kind>: ObjectRef<Kind> {
-    fn context<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().context.as_ref()
-    }
-
-    fn id<'a>(&'a self) -> Option<&'a XsdAnyUri>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().id.as_ref()
-    }
-
-    fn kind<'a>(&'a self) -> Option<&'a Kind>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().kind.as_ref()
-    }
-
-    fn attachment<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
+pub trait ObjectExt<Kind>: AsObject<Kind> {
+    fn attachment<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
         Kind: 'a,
     {
         self.object_ref().attachment.as_ref()
     }
 
-    fn attributed_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().attributed_to.as_ref()
-    }
-
-    fn audience<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().audience.as_ref()
-    }
-
-    fn content<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().content.as_ref()
-    }
-
-    fn name<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().name.as_ref()
-    }
-
-    fn summary<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().summary.as_ref()
-    }
-
-    fn url<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().url.as_ref()
-    }
-
-    fn media_type<'a>(&'a self) -> Option<&'a MimeMediaType>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().media_type.as_ref()
-    }
-
-    fn generator<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().generator.as_ref()
-    }
-
-    fn image<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().image.as_ref()
-    }
-
-    fn location<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().location.as_ref()
-    }
-
-    fn preview<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().preview.as_ref()
-    }
-
-    fn start_time<'a>(&'a self) -> Option<&'a XsdDateTime>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().start_time.as_ref()
-    }
-
-    fn end_time<'a>(&'a self) -> Option<&'a XsdDateTime>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().end_time.as_ref()
-    }
-
-    fn duration<'a>(&'a self) -> Option<&'a XsdDuration>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().duration.as_ref()
-    }
-
-    fn published<'a>(&'a self) -> Option<&'a XsdDateTime>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().published.as_ref()
-    }
-
-    fn updated<'a>(&'a self) -> Option<&'a XsdDateTime>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().updated.as_ref()
-    }
-
-    fn in_reply_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().in_reply_to.as_ref()
-    }
-
-    fn replies<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().replies.as_ref()
-    }
-
-    fn to<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().to.as_ref()
-    }
-
-    fn bto<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().bto.as_ref()
-    }
-
-    fn cc<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().cc.as_ref()
-    }
-
-    fn bcc<'a>(&'a self) -> Option<&'a OneOrMany<AnyObject>>
-    where
-        Kind: 'a,
-    {
-        self.object_ref().bcc.as_ref()
-    }
-}
-
-pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
-    fn set_context<T>(&mut self, context: T) -> &mut Self
-    where
-        T: Into<AnyObject>,
-    {
-        self.object_mut().context = Some(context.into().into());
-        self
-    }
-
-    fn set_many_contexts<I, T>(&mut self, items: I) -> &mut Self
-    where
-        I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
-    {
-        let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        self.object_mut().context = Some(v.into());
-        self
-    }
-
-    fn add_context<T>(&mut self, context: T) -> &mut Self
-    where
-        T: Into<AnyObject>,
-    {
-        let c = match self.object_mut().context.take() {
-            Some(mut c) => {
-                c.add(context.into());
-                c
-            }
-            None => vec![context.into()].into(),
-        };
-        self.object_mut().context = Some(c);
-        self
-    }
-
-    fn take_context(&mut self) -> Option<OneOrMany<AnyObject>> {
-        self.object_mut().context.take()
-    }
-
-    fn delete_context(&mut self) -> &mut Self {
-        self.object_mut().context = None;
-        self
-    }
-
-    fn set_id(&mut self, id: XsdAnyUri) -> &mut Self {
-        self.object_mut().id = Some(id);
-        self
-    }
-
-    fn take_id(&mut self) -> Option<XsdAnyUri> {
-        self.object_mut().id.take()
-    }
-
-    fn delete_id(&mut self) -> &mut Self {
-        self.object_mut().id = None;
-        self
-    }
-
-    fn set_kind(&mut self, kind: Kind) -> &mut Self {
-        self.object_mut().kind = Some(kind);
-        self
-    }
-
-    fn take_kind(&mut self) -> Option<Kind> {
-        self.object_mut().kind.take()
-    }
-
-    fn delete_kind(&mut self) -> &mut Self {
-        self.object_mut().kind = None;
-        self
-    }
-
     fn set_attachment<T>(&mut self, attachment: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().attachment = Some(attachment.into().into());
         self
@@ -329,7 +62,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_attachments<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().attachment = Some(v.into());
@@ -338,7 +71,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_attachment<T>(&mut self, attachment: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().attachment.take() {
             Some(mut a) => {
@@ -351,7 +84,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_attachment(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_attachment(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().attachment.take()
     }
 
@@ -360,9 +93,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn attributed_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().attributed_to.as_ref()
+    }
+
     fn set_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().attributed_to = Some(attributed_to.into().into());
         self
@@ -371,7 +111,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_attributed_tos<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().attributed_to = Some(v.into());
@@ -380,7 +120,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().attributed_to.take() {
             Some(mut a) => {
@@ -393,7 +133,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_attributed_to(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_attributed_to(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().attributed_to.take()
     }
 
@@ -402,9 +142,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn audience<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().audience.as_ref()
+    }
+
     fn set_audience<T>(&mut self, audience: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().audience = Some(audience.into().into());
         self
@@ -413,7 +160,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_audiences<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().audience = Some(v.into());
@@ -422,7 +169,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_audience<T>(&mut self, audience: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().audience.take() {
             Some(mut a) => {
@@ -435,7 +182,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_audience(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_audience(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().audience.take()
     }
 
@@ -444,6 +191,13 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn content<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().content.as_ref()
+    }
+
     fn set_content<T>(&mut self, content: T) -> &mut Self
     where
         T: Into<AnyString>,
@@ -486,46 +240,11 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn set_name<T>(&mut self, name: T) -> &mut Self
+    fn summary<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>>
     where
-        T: Into<AnyString>,
+        Kind: 'a,
     {
-        self.object_mut().name = Some(name.into().into());
-        self
-    }
-
-    fn set_many_names<I, T>(&mut self, items: I) -> &mut Self
-    where
-        I: IntoIterator<Item = T>,
-        T: Into<AnyString>,
-    {
-        let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        self.object_mut().name = Some(v.into());
-        self
-    }
-
-    fn add_name<T>(&mut self, name: T) -> &mut Self
-    where
-        T: Into<AnyString>,
-    {
-        let a = match self.object_mut().name.take() {
-            Some(mut a) => {
-                a.add(name.into());
-                a
-            }
-            None => vec![name.into()].into(),
-        };
-        self.object_mut().name = Some(a);
-        self
-    }
-
-    fn take_name(&mut self) -> Option<OneOrMany<AnyString>> {
-        self.object_mut().name.take()
-    }
-
-    fn delete_name(&mut self) -> &mut Self {
-        self.object_mut().name = None;
-        self
+        self.object_ref().summary.as_ref()
     }
 
     fn set_summary<T>(&mut self, summary: T) -> &mut Self
@@ -570,9 +289,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn url<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().url.as_ref()
+    }
+
     fn set_url<T>(&mut self, url: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().url = Some(url.into().into());
         self
@@ -581,7 +307,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_urls<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().url = Some(v.into());
@@ -590,7 +316,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_url<T>(&mut self, url: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().url.take() {
             Some(mut a) => {
@@ -603,7 +329,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_url(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_url(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().url.take()
     }
 
@@ -612,23 +338,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn set_media_type(&mut self, media_type: MimeMediaType) -> &mut Self {
-        self.object_mut().media_type = Some(media_type);
-        self
-    }
-
-    fn take_media_type(&mut self) -> Option<MimeMediaType> {
-        self.object_mut().media_type.take()
-    }
-
-    fn delete_media_type(&mut self) -> &mut Self {
-        self.object_mut().media_type = None;
-        self
+    fn generator<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().generator.as_ref()
     }
 
     fn set_generator<T>(&mut self, generator: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().generator = Some(generator.into().into());
         self
@@ -637,7 +356,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_generators<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().generator = Some(v.into());
@@ -646,7 +365,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_generator<T>(&mut self, generator: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().generator.take() {
             Some(mut a) => {
@@ -659,7 +378,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_generator(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_generator(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().generator.take()
     }
 
@@ -668,9 +387,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn image<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().image.as_ref()
+    }
+
     fn set_image<T>(&mut self, image: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().image = Some(image.into().into());
         self
@@ -679,7 +405,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_images<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().image = Some(v.into());
@@ -688,7 +414,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_image<T>(&mut self, image: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().image.take() {
             Some(mut a) => {
@@ -701,7 +427,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_image(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_image(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().image.take()
     }
 
@@ -710,9 +436,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn location<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().location.as_ref()
+    }
+
     fn set_location<T>(&mut self, location: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().location = Some(location.into().into());
         self
@@ -721,7 +454,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_locations<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().location = Some(v.into());
@@ -730,7 +463,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_location<T>(&mut self, location: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().location.take() {
             Some(mut a) => {
@@ -743,7 +476,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_location(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_location(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().location.take()
     }
 
@@ -752,46 +485,11 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn set_preview<T>(&mut self, preview: T) -> &mut Self
+    fn start_time<'a>(&'a self) -> Option<&'a XsdDateTime>
     where
-        T: Into<AnyObject>,
+        Kind: 'a,
     {
-        self.object_mut().preview = Some(preview.into().into());
-        self
-    }
-
-    fn set_many_previews<I, T>(&mut self, items: I) -> &mut Self
-    where
-        I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
-    {
-        let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        self.object_mut().preview = Some(v.into());
-        self
-    }
-
-    fn add_preview<T>(&mut self, preview: T) -> &mut Self
-    where
-        T: Into<AnyObject>,
-    {
-        let a = match self.object_mut().preview.take() {
-            Some(mut a) => {
-                a.add(preview.into());
-                a
-            }
-            None => vec![preview.into()].into(),
-        };
-        self.object_mut().preview = Some(a);
-        self
-    }
-
-    fn take_preview(&mut self) -> Option<OneOrMany<AnyObject>> {
-        self.object_mut().preview.take()
-    }
-
-    fn delete_preview(&mut self) -> &mut Self {
-        self.object_mut().preview = None;
-        self
+        self.object_ref().start_time.as_ref()
     }
 
     fn set_start_time(&mut self, start_time: XsdDateTime) -> &mut Self {
@@ -808,6 +506,13 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn end_time<'a>(&'a self) -> Option<&'a XsdDateTime>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().end_time.as_ref()
+    }
+
     fn set_end_time(&mut self, end_time: XsdDateTime) -> &mut Self {
         self.object_mut().end_time = Some(end_time);
         self
@@ -822,6 +527,13 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn duration<'a>(&'a self) -> Option<&'a XsdDuration>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().duration.as_ref()
+    }
+
     fn set_duration(&mut self, duration: XsdDuration) -> &mut Self {
         self.object_mut().duration = Some(duration);
         self
@@ -836,6 +548,13 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn published<'a>(&'a self) -> Option<&'a XsdDateTime>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().published.as_ref()
+    }
+
     fn set_published(&mut self, published: XsdDateTime) -> &mut Self {
         self.object_mut().published = Some(published);
         self
@@ -850,6 +569,13 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn updated<'a>(&'a self) -> Option<&'a XsdDateTime>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().updated.as_ref()
+    }
+
     fn set_updated(&mut self, updated: XsdDateTime) -> &mut Self {
         self.object_mut().updated = Some(updated);
         self
@@ -864,9 +590,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn in_reply_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().in_reply_to.as_ref()
+    }
+
     fn set_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().in_reply_to = Some(in_reply_to.into().into());
         self
@@ -875,7 +608,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_in_reply_tos<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().in_reply_to = Some(v.into());
@@ -884,7 +617,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().in_reply_to.take() {
             Some(mut a) => {
@@ -897,7 +630,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_in_reply_to(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_in_reply_to(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().in_reply_to.take()
     }
 
@@ -906,9 +639,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn replies<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().replies.as_ref()
+    }
+
     fn set_replies<T>(&mut self, replies: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().replies = Some(replies.into().into());
         self
@@ -917,7 +657,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_repliess<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().replies = Some(v.into());
@@ -926,7 +666,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_replies<T>(&mut self, replies: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().replies.take() {
             Some(mut a) => {
@@ -939,7 +679,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_replies(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_replies(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().replies.take()
     }
 
@@ -948,9 +688,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().to.as_ref()
+    }
+
     fn set_to<T>(&mut self, to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().to = Some(to.into().into());
         self
@@ -959,7 +706,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_tos<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().to = Some(v.into());
@@ -968,7 +715,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_to<T>(&mut self, to: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().to.take() {
             Some(mut a) => {
@@ -981,7 +728,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_to(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_to(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().to.take()
     }
 
@@ -990,9 +737,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn bto<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().bto.as_ref()
+    }
+
     fn set_bto<T>(&mut self, bto: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().bto = Some(bto.into().into());
         self
@@ -1001,7 +755,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_btos<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().bto = Some(v.into());
@@ -1010,7 +764,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_bto<T>(&mut self, bto: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().bto.take() {
             Some(mut a) => {
@@ -1023,7 +777,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_bto(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_bto(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().bto.take()
     }
 
@@ -1032,9 +786,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn cc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().cc.as_ref()
+    }
+
     fn set_cc<T>(&mut self, cc: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().cc = Some(cc.into().into());
         self
@@ -1043,7 +804,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_ccs<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().cc = Some(v.into());
@@ -1052,7 +813,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_cc<T>(&mut self, cc: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().cc.take() {
             Some(mut a) => {
@@ -1065,7 +826,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_cc(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_cc(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().cc.take()
     }
 
@@ -1074,9 +835,16 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
+    fn bcc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
+    where
+        Kind: 'a,
+    {
+        self.object_ref().bcc.as_ref()
+    }
+
     fn set_bcc<T>(&mut self, bcc: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.object_mut().bcc = Some(bcc.into().into());
         self
@@ -1085,7 +853,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     fn set_many_bcc<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.object_mut().bcc = Some(v.into());
@@ -1094,7 +862,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
 
     fn add_bcc<T>(&mut self, bcc: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let a = match self.object_mut().bcc.take() {
             Some(mut a) => {
@@ -1107,7 +875,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
         self
     }
 
-    fn take_bcc(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_bcc(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.object_mut().bcc.take()
     }
 
@@ -1117,7 +885,7 @@ pub trait ObjectMutExt<Kind>: ObjectMut<Kind> {
     }
 }
 
-pub trait ApObjectRefExt<Inner>: ApObjectRef<Inner> {
+pub trait ApObjectExt<Inner>: AsApObject<Inner> {
     fn shares<'a>(&'a self) -> Option<&'a XsdAnyUri>
     where
         Inner: 'a,
@@ -1125,29 +893,6 @@ pub trait ApObjectRefExt<Inner>: ApObjectRef<Inner> {
         self.ap_object_ref().shares.as_ref()
     }
 
-    fn likes<'a>(&'a self) -> Option<&'a XsdAnyUri>
-    where
-        Inner: 'a,
-    {
-        self.ap_object_ref().likes.as_ref()
-    }
-
-    fn source<'a>(&'a self) -> Option<&'a AnyObject>
-    where
-        Inner: 'a,
-    {
-        self.ap_object_ref().source.as_ref()
-    }
-
-    fn upload_media<'a>(&'a self) -> Option<&'a OneOrMany<XsdAnyUri>>
-    where
-        Inner: 'a,
-    {
-        self.ap_object_ref().upload_media.as_ref()
-    }
-}
-
-pub trait ApObjectMutExt<Inner>: ApObjectMut<Inner> {
     fn set_shares(&mut self, shares: XsdAnyUri) -> &mut Self {
         self.ap_object_mut().shares = Some(shares);
         self
@@ -1162,6 +907,13 @@ pub trait ApObjectMutExt<Inner>: ApObjectMut<Inner> {
         self
     }
 
+    fn likes<'a>(&'a self) -> Option<&'a XsdAnyUri>
+    where
+        Inner: 'a,
+    {
+        self.ap_object_ref().likes.as_ref()
+    }
+
     fn set_likes(&mut self, likes: XsdAnyUri) -> &mut Self {
         self.ap_object_mut().likes = Some(likes);
         self
@@ -1176,15 +928,22 @@ pub trait ApObjectMutExt<Inner>: ApObjectMut<Inner> {
         self
     }
 
+    fn source<'a>(&'a self) -> Option<&'a AnyBase>
+    where
+        Inner: 'a,
+    {
+        self.ap_object_ref().source.as_ref()
+    }
+
     fn set_source<T>(&mut self, source: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.ap_object_mut().source = Some(source.into());
         self
     }
 
-    fn take_source(&mut self) -> Option<AnyObject> {
+    fn take_source(&mut self) -> Option<AnyBase> {
         self.ap_object_mut().source.take()
     }
 
@@ -1193,6 +952,13 @@ pub trait ApObjectMutExt<Inner>: ApObjectMut<Inner> {
         self
     }
 
+    fn upload_media<'a>(&'a self) -> Option<&'a OneOrMany<XsdAnyUri>>
+    where
+        Inner: 'a,
+    {
+        self.ap_object_ref().upload_media.as_ref()
+    }
+
     fn set_upload_media<T>(&mut self, upload_media: XsdAnyUri) -> &mut Self {
         self.ap_object_mut().upload_media = Some(upload_media.into());
         self
@@ -1229,29 +995,11 @@ pub trait ApObjectMutExt<Inner>: ApObjectMut<Inner> {
     }
 }
 
-pub trait PlaceRefExt: PlaceRef {
+pub trait PlaceExt: AsPlace {
     fn accuracy(&self) -> Option<&XsdFloat> {
         self.place_ref().accuracy.as_ref()
     }
 
-    fn altitude(&self) -> Option<&XsdFloat> {
-        self.place_ref().altitude.as_ref()
-    }
-
-    fn latitude(&self) -> Option<&XsdFloat> {
-        self.place_ref().latitude.as_ref()
-    }
-
-    fn longitude(&self) -> Option<&XsdFloat> {
-        self.place_ref().longitude.as_ref()
-    }
-
-    fn units(&self) -> Option<&Unit> {
-        self.place_ref().units.as_ref()
-    }
-}
-
-pub trait PlaceMutExt: PlaceMut {
     fn set_accuracy<T>(&mut self, float: T) -> &mut Self
     where
         T: Into<XsdFloat>,
@@ -1269,6 +1017,10 @@ pub trait PlaceMutExt: PlaceMut {
         self
     }
 
+    fn altitude(&self) -> Option<&XsdFloat> {
+        self.place_ref().altitude.as_ref()
+    }
+
     fn set_altitude<T>(&mut self, float: T) -> &mut Self
     where
         T: Into<XsdFloat>,
@@ -1286,6 +1038,10 @@ pub trait PlaceMutExt: PlaceMut {
         self
     }
 
+    fn latitude(&self) -> Option<&XsdFloat> {
+        self.place_ref().latitude.as_ref()
+    }
+
     fn set_latitude<T>(&mut self, float: T) -> &mut Self
     where
         T: Into<XsdFloat>,
@@ -1303,6 +1059,10 @@ pub trait PlaceMutExt: PlaceMut {
         self
     }
 
+    fn longitude(&self) -> Option<&XsdFloat> {
+        self.place_ref().longitude.as_ref()
+    }
+
     fn set_longitude<T>(&mut self, float: T) -> &mut Self
     where
         T: Into<XsdFloat>,
@@ -1320,6 +1080,10 @@ pub trait PlaceMutExt: PlaceMut {
         self
     }
 
+    fn radius(&self) -> Option<&XsdFloat> {
+        self.place_ref().radius.as_ref()
+    }
+
     fn set_radius<T>(&mut self, float: T) -> &mut Self
     where
         T: Into<XsdFloat>,
@@ -1337,6 +1101,10 @@ pub trait PlaceMutExt: PlaceMut {
         self
     }
 
+    fn units(&self) -> Option<&Unit> {
+        self.place_ref().units.as_ref()
+    }
+
     fn set_units<T>(&mut self, units: T) -> &mut Self
     where
         T: Into<Unit>,
@@ -1355,22 +1123,20 @@ pub trait PlaceMutExt: PlaceMut {
     }
 }
 
-pub trait ProfileRefExt: ProfileRef {
-    fn describes(&self) -> Option<&AnyObject> {
+pub trait ProfileExt: AsProfile {
+    fn describes(&self) -> Option<&AnyBase> {
         self.profile_ref().describes.as_ref()
     }
-}
 
-pub trait ProfileMutExt: ProfileMut {
     fn set_describes<T>(&mut self, describes: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.profile_mut().describes = Some(describes.into());
         self
     }
 
-    fn take_describes(&mut self) -> Option<AnyObject> {
+    fn take_describes(&mut self) -> Option<AnyBase> {
         self.profile_mut().describes.take()
     }
 
@@ -1380,30 +1146,20 @@ pub trait ProfileMutExt: ProfileMut {
     }
 }
 
-pub trait RelationshipRefExt: RelationshipRef {
-    fn subject(&self) -> Option<&AnyObject> {
+pub trait RelationshipExt: AsRelationship {
+    fn subject(&self) -> Option<&AnyBase> {
         self.relationship_ref().subject.as_ref()
     }
 
-    fn object(&self) -> Option<&OneOrMany<AnyObject>> {
-        self.relationship_ref().object.as_ref()
-    }
-
-    fn relationship(&self) -> Option<&OneOrMany<AnyObject>> {
-        self.relationship_ref().relationship.as_ref()
-    }
-}
-
-pub trait RelationshipMutExt: RelationshipMut {
     fn set_subject<T>(&mut self, subject: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.relationship_mut().subject = Some(subject.into());
         self
     }
 
-    fn take_subject(&mut self) -> Option<AnyObject> {
+    fn take_subject(&mut self) -> Option<AnyBase> {
         self.relationship_mut().subject.take()
     }
 
@@ -1412,9 +1168,13 @@ pub trait RelationshipMutExt: RelationshipMut {
         self
     }
 
+    fn object(&self) -> Option<&OneOrMany<AnyBase>> {
+        self.relationship_ref().object.as_ref()
+    }
+
     fn set_object<T>(&mut self, object: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.relationship_mut().object = Some(object.into().into());
         self
@@ -1423,7 +1183,7 @@ pub trait RelationshipMutExt: RelationshipMut {
     fn set_many_objects<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.relationship_mut().object = Some(v.into());
@@ -1432,7 +1192,7 @@ pub trait RelationshipMutExt: RelationshipMut {
 
     fn add_object<T>(&mut self, object: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v = match self.relationship_mut().object.take() {
             Some(mut v) => {
@@ -1445,7 +1205,7 @@ pub trait RelationshipMutExt: RelationshipMut {
         self
     }
 
-    fn take_object(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_object(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.relationship_mut().object.take()
     }
 
@@ -1454,9 +1214,13 @@ pub trait RelationshipMutExt: RelationshipMut {
         self
     }
 
+    fn relationship(&self) -> Option<&OneOrMany<AnyBase>> {
+        self.relationship_ref().relationship.as_ref()
+    }
+
     fn set_relationship<T>(&mut self, relationship: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.relationship_mut().relationship = Some(relationship.into().into());
         self
@@ -1465,7 +1229,7 @@ pub trait RelationshipMutExt: RelationshipMut {
     fn set_many_relationships<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.relationship_mut().relationship = Some(v.into());
@@ -1474,7 +1238,7 @@ pub trait RelationshipMutExt: RelationshipMut {
 
     fn add_relationship<T>(&mut self, relationship: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v = match self.relationship_mut().relationship.take() {
             Some(mut v) => {
@@ -1487,7 +1251,7 @@ pub trait RelationshipMutExt: RelationshipMut {
         self
     }
 
-    fn take_relationship(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_relationship(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.relationship_mut().relationship.take()
     }
 
@@ -1497,20 +1261,14 @@ pub trait RelationshipMutExt: RelationshipMut {
     }
 }
 
-pub trait TombstoneRefExt: TombstoneRef {
-    fn former_type(&self) -> Option<&OneOrMany<AnyObject>> {
+pub trait TombstoneExt: AsTombstone {
+    fn former_type(&self) -> Option<&OneOrMany<AnyBase>> {
         self.tombstone_ref().former_type.as_ref()
     }
 
-    fn deleted(&self) -> Option<&XsdDateTime> {
-        self.tombstone_ref().deleted.as_ref()
-    }
-}
-
-pub trait TombstoneMutExt: TombstoneMut {
     fn set_former_type<T>(&mut self, former_type: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         self.tombstone_mut().former_type = Some(former_type.into().into());
         self
@@ -1519,7 +1277,7 @@ pub trait TombstoneMutExt: TombstoneMut {
     fn set_many_former_types<I, T>(&mut self, items: I) -> &mut Self
     where
         I: IntoIterator<Item = T>,
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
         self.tombstone_mut().former_type = Some(v.into());
@@ -1528,7 +1286,7 @@ pub trait TombstoneMutExt: TombstoneMut {
 
     fn add_former_type<T>(&mut self, former_type: T) -> &mut Self
     where
-        T: Into<AnyObject>,
+        T: Into<AnyBase>,
     {
         let v = match self.tombstone_mut().former_type.take() {
             Some(mut v) => {
@@ -1541,7 +1299,7 @@ pub trait TombstoneMutExt: TombstoneMut {
         self
     }
 
-    fn take_former_type(&mut self) -> Option<OneOrMany<AnyObject>> {
+    fn take_former_type(&mut self) -> Option<OneOrMany<AnyBase>> {
         self.tombstone_mut().former_type.take()
     }
 
@@ -1550,6 +1308,10 @@ pub trait TombstoneMutExt: TombstoneMut {
         self
     }
 
+    fn deleted(&self) -> Option<&XsdDateTime> {
+        self.tombstone_ref().deleted.as_ref()
+    }
+
     fn set_deleted<T>(&mut self, deleted: T) -> &mut Self
     where
         T: Into<XsdDateTime>,
@@ -1577,78 +1339,45 @@ pub type Note = Object<NoteType>;
 pub type Page = Object<PageType>;
 pub type Video = Object<VideoType>;
 
-#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-#[serde(transparent)]
-struct IdOrObject(Either<XsdAnyUri, Box<Object<serde_json::Value>>>);
-
-#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-#[serde(transparent)]
-pub struct AnyObject(Either<IdOrObject, XsdString>);
-
 #[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize, TypedBuilder)]
 #[serde(rename_all = "camelCase")]
 #[builder(doc)]
 pub struct Object<Kind> {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub context: Option<OneOrMany<AnyObject>>,
+    pub attachment: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub id: Option<XsdAnyUri>,
-
-    #[serde(rename = "type")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option))]
-    pub kind: Option<Kind>,
+    pub attributed_to: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub attachment: Option<OneOrMany<AnyObject>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option, into))]
-    pub attributed_to: Option<OneOrMany<AnyObject>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option, into))]
-    pub audience: Option<OneOrMany<AnyObject>>,
+    pub audience: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
     pub content: Option<OneOrMany<AnyString>>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option, into))]
-    pub name: Option<OneOrMany<AnyString>>,
-
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
     pub summary: Option<OneOrMany<AnyString>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub url: Option<OneOrMany<AnyObject>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option))]
-    pub media_type: Option<MimeMediaType>,
+    pub url: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub generator: Option<OneOrMany<AnyObject>>,
+    pub generator: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub image: Option<OneOrMany<AnyObject>>,
+    pub image: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub location: Option<OneOrMany<AnyObject>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[builder(default, setter(strip_option, into))]
-    pub preview: Option<OneOrMany<AnyObject>>,
+    pub location: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
@@ -1672,31 +1401,30 @@ pub struct Object<Kind> {
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub in_reply_to: Option<OneOrMany<AnyObject>>,
+    pub in_reply_to: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub replies: Option<OneOrMany<AnyObject>>,
+    pub replies: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub to: Option<OneOrMany<AnyObject>>,
+    pub to: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub bto: Option<OneOrMany<AnyObject>>,
+    pub bto: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub cc: Option<OneOrMany<AnyObject>>,
+    pub cc: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub bcc: Option<OneOrMany<AnyObject>>,
+    pub bcc: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
-    #[builder(default)]
-    pub unparsed: Unparsed,
+    pub inner: Base<Kind>,
 }
 
 #[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize, TypedBuilder)]
@@ -1713,7 +1441,7 @@ pub struct ApObject<Inner> {
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub source: Option<AnyObject>,
+    pub source: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
@@ -1759,7 +1487,7 @@ pub struct Place {
 pub struct Profile {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub describes: Option<AnyObject>,
+    pub describes: Option<AnyBase>,
 
     #[serde(flatten)]
     pub inner: Object<ProfileType>,
@@ -1770,15 +1498,15 @@ pub struct Profile {
 pub struct Relationship {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub subject: Option<AnyObject>,
+    pub subject: Option<AnyBase>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub object: Option<OneOrMany<AnyObject>>,
+    pub object: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub relationship: Option<OneOrMany<AnyObject>>,
+    pub relationship: Option<OneOrMany<AnyBase>>,
 
     #[serde(flatten)]
     pub inner: Object<RelationshipType>,
@@ -1789,7 +1517,7 @@ pub struct Relationship {
 pub struct Tombstone {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
-    pub former_type: Option<OneOrMany<AnyObject>>,
+    pub former_type: Option<OneOrMany<AnyBase>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     #[builder(default, setter(strip_option, into))]
@@ -1799,212 +1527,50 @@ pub struct Tombstone {
     pub inner: Object<TombstoneType>,
 }
 
-impl AnyObject {
-    pub fn as_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
-        self.0.as_ref().left().and_then(|l| l.as_xsd_any_uri())
-    }
-
-    pub fn as_xsd_string(&self) -> Option<&XsdString> {
-        self.0.as_ref().right()
-    }
-
-    pub fn as_object(&self) -> Option<&Object<serde_json::Value>> {
-        self.0.as_ref().left().and_then(|l| l.as_object())
-    }
-
-    pub fn id(self) -> Option<XsdAnyUri> {
-        self.0.left().and_then(|l| l.id())
-    }
-
-    pub fn xsd_string(self) -> Option<XsdString> {
-        self.0.right()
-    }
-
-    pub fn object(self) -> Option<Object<serde_json::Value>> {
-        self.0.left().and_then(|l| l.object())
-    }
-
-    pub fn set_xsd_any_uri(&mut self, id: XsdAnyUri) {
-        self.0 = Either::Left(IdOrObject::from_xsd_any_uri(id));
-    }
-
-    pub fn set_object(&mut self, object: Object<serde_json::Value>) {
-        self.0 = Either::Left(IdOrObject::from_object(object));
-    }
-
-    pub fn set_xsd_string(&mut self, xsd_string: XsdString) {
-        self.0 = Either::Right(xsd_string);
-    }
-
-    pub fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
-        AnyObject(Either::Left(IdOrObject::from_xsd_any_uri(id)))
-    }
-
-    pub fn from_object(object: Object<serde_json::Value>) -> Self {
-        AnyObject(Either::Left(IdOrObject::from_object(object)))
-    }
-
-    pub fn from_xsd_string(xsd_string: XsdString) -> Self {
-        AnyObject(Either::Right(xsd_string))
-    }
-}
-
-impl IdOrObject {
-    fn as_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
-        self.0.as_ref().left()
-    }
-
-    fn as_object(&self) -> Option<&Object<serde_json::Value>> {
-        self.0.as_ref().right().map(|b| b.as_ref())
-    }
-
-    fn id(self) -> Option<XsdAnyUri> {
-        self.0.left()
-    }
-
-    fn object(self) -> Option<Object<serde_json::Value>> {
-        self.0.right().map(|b| *b)
-    }
-
-    fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
-        IdOrObject(Either::Left(id))
-    }
-
-    fn from_object(object: Object<serde_json::Value>) -> Self {
-        IdOrObject(Either::Right(Box::new(object)))
-    }
-}
-
-impl OneOrMany<AnyObject> {
-    pub fn as_single_xsd_any_uri(&self) -> Option<&XsdAnyUri> {
-        self.as_one().and_then(|inner| inner.as_xsd_any_uri())
-    }
-
-    pub fn as_single_xsd_string(&self) -> Option<&XsdString> {
-        self.as_one().and_then(|inner| inner.as_xsd_string())
-    }
-
-    pub fn as_single_object(&self) -> Option<&Object<serde_json::Value>> {
-        self.as_one().and_then(|inner| inner.as_object())
-    }
-
-    pub fn single_xsd_any_uri(self) -> Option<XsdAnyUri> {
-        self.one().and_then(|inner| inner.id())
-    }
-
-    pub fn single_xsd_string(self) -> Option<XsdString> {
-        self.one().and_then(|inner| inner.xsd_string())
-    }
-
-    pub fn single_object(self) -> Option<Object<serde_json::Value>> {
-        self.one().and_then(|inner| inner.object())
-    }
-
-    pub fn from_xsd_any_uri(id: XsdAnyUri) -> Self {
-        OneOrMany(Either::Left(AnyObject::from_xsd_any_uri(id)))
-    }
-
-    pub fn from_xsd_string(xsd_string: XsdString) -> Self {
-        OneOrMany(Either::Left(AnyObject::from_xsd_string(xsd_string)))
-    }
-
-    pub fn from_object(object: Object<serde_json::Value>) -> Self {
-        OneOrMany(Either::Left(AnyObject::from_object(object)))
-    }
-
-    pub fn set_single_xsd_any_uri(&mut self, id: XsdAnyUri) -> &mut Self {
-        self.0 = Either::Left(AnyObject::from_xsd_any_uri(id));
-        self
-    }
-
-    pub fn set_single_xsd_string(&mut self, xsd_string: XsdString) -> &mut Self {
-        self.0 = Either::Left(AnyObject::from_xsd_string(xsd_string));
-        self
-    }
-
-    pub fn set_single_object(&mut self, object: Object<serde_json::Value>) -> &mut Self {
-        self.0 = Either::Left(AnyObject::from_object(object));
-        self
-    }
-
-    pub fn add_xsd_any_uri(&mut self, id: XsdAnyUri) -> &mut Self {
-        self.add(AnyObject::from_xsd_any_uri(id))
-    }
-
-    pub fn add_xsd_string(&mut self, xsd_string: XsdString) -> &mut Self {
-        self.add(AnyObject::from_xsd_string(xsd_string))
-    }
-
-    pub fn add_object(&mut self, object: Object<serde_json::Value>) -> &mut Self {
-        self.add(AnyObject::from_object(object))
-    }
-}
-
-impl Object<serde_json::Value> {
-    pub fn solidify<Kind>(self) -> Result<Object<Kind>, serde_json::Error>
-    where
-        Kind: serde::de::DeserializeOwned,
-    {
-        self.try_map_kind(serde_json::from_value)
-    }
-}
-
 impl<Kind> Object<Kind> {
-    fn extending(mut unparsed: Unparsed) -> Result<Self, serde_json::Error>
+    fn extending(mut base: Base<Kind>) -> Result<Self, serde_json::Error>
     where
         Kind: serde::de::DeserializeOwned,
     {
         Ok(Object {
-            kind: UnparsedMutExt::remove(&mut unparsed, "type")?,
-            context: UnparsedMutExt::remove(&mut unparsed, "context")?,
-            id: UnparsedMutExt::remove(&mut unparsed, "id")?,
-            attachment: UnparsedMutExt::remove(&mut unparsed, "attachment")?,
-            attributed_to: UnparsedMutExt::remove(&mut unparsed, "attributedTo")?,
-            audience: UnparsedMutExt::remove(&mut unparsed, "audience")?,
-            content: UnparsedMutExt::remove(&mut unparsed, "content")?,
-            name: UnparsedMutExt::remove(&mut unparsed, "name")?,
-            summary: UnparsedMutExt::remove(&mut unparsed, "summary")?,
-            url: UnparsedMutExt::remove(&mut unparsed, "url")?,
-            media_type: UnparsedMutExt::remove(&mut unparsed, "mediaType")?,
-            generator: UnparsedMutExt::remove(&mut unparsed, "generator")?,
-            image: UnparsedMutExt::remove(&mut unparsed, "image")?,
-            location: UnparsedMutExt::remove(&mut unparsed, "location")?,
-            preview: UnparsedMutExt::remove(&mut unparsed, "preview")?,
-            start_time: UnparsedMutExt::remove(&mut unparsed, "startTime")?,
-            end_time: UnparsedMutExt::remove(&mut unparsed, "endTime")?,
-            duration: UnparsedMutExt::remove(&mut unparsed, "duration")?,
-            published: UnparsedMutExt::remove(&mut unparsed, "published")?,
-            updated: UnparsedMutExt::remove(&mut unparsed, "updated")?,
-            in_reply_to: UnparsedMutExt::remove(&mut unparsed, "inReplyTo")?,
-            replies: UnparsedMutExt::remove(&mut unparsed, "replies")?,
-            to: UnparsedMutExt::remove(&mut unparsed, "to")?,
-            bto: UnparsedMutExt::remove(&mut unparsed, "bto")?,
-            cc: UnparsedMutExt::remove(&mut unparsed, "cc")?,
-            bcc: UnparsedMutExt::remove(&mut unparsed, "bcc")?,
-            unparsed,
+            attachment: base.remove("attachment")?,
+            attributed_to: base.remove("attributedTo")?,
+            audience: base.remove("audience")?,
+            content: base.remove("content")?,
+            summary: base.remove("summary")?,
+            url: base.remove("url")?,
+            generator: base.remove("generator")?,
+            image: base.remove("image")?,
+            location: base.remove("location")?,
+            start_time: base.remove("startTime")?,
+            end_time: base.remove("endTime")?,
+            duration: base.remove("duration")?,
+            published: base.remove("published")?,
+            updated: base.remove("updated")?,
+            in_reply_to: base.remove("inReplyTo")?,
+            replies: base.remove("replies")?,
+            to: base.remove("to")?,
+            bto: base.remove("bto")?,
+            cc: base.remove("cc")?,
+            bcc: base.remove("bcc")?,
+            inner: base,
         })
     }
 
-    fn retracting(self) -> Result<Unparsed, serde_json::Error>
+    fn retracting(self) -> Result<Base<Kind>, serde_json::Error>
     where
         Kind: serde::ser::Serialize,
     {
         let Object {
-            kind,
-            context,
-            id,
             attachment,
             attributed_to,
             audience,
             content,
-            name,
             summary,
             url,
-            media_type,
             generator,
             image,
             location,
-            preview,
             start_time,
             end_time,
             duration,
@@ -2016,129 +1582,39 @@ impl<Kind> Object<Kind> {
             bto,
             cc,
             bcc,
-            mut unparsed,
+            mut inner,
         } = self;
 
-        UnparsedMutExt::insert(&mut unparsed, "type", kind)?;
-        UnparsedMutExt::insert(&mut unparsed, "context", context)?;
-        UnparsedMutExt::insert(&mut unparsed, "id", id)?;
-        UnparsedMutExt::insert(&mut unparsed, "attachment", attachment)?;
-        UnparsedMutExt::insert(&mut unparsed, "attributedTo", attributed_to)?;
-        UnparsedMutExt::insert(&mut unparsed, "audience", audience)?;
-        UnparsedMutExt::insert(&mut unparsed, "content", content)?;
-        UnparsedMutExt::insert(&mut unparsed, "name", name)?;
-        UnparsedMutExt::insert(&mut unparsed, "summary", summary)?;
-        UnparsedMutExt::insert(&mut unparsed, "url", url)?;
-        UnparsedMutExt::insert(&mut unparsed, "mediaType", media_type)?;
-        UnparsedMutExt::insert(&mut unparsed, "generator", generator)?;
-        UnparsedMutExt::insert(&mut unparsed, "image", image)?;
-        UnparsedMutExt::insert(&mut unparsed, "location", location)?;
-        UnparsedMutExt::insert(&mut unparsed, "preview", preview)?;
-        UnparsedMutExt::insert(&mut unparsed, "startTime", start_time)?;
-        UnparsedMutExt::insert(&mut unparsed, "endTime", end_time)?;
-        UnparsedMutExt::insert(&mut unparsed, "duration", duration)?;
-        UnparsedMutExt::insert(&mut unparsed, "published", published)?;
-        UnparsedMutExt::insert(&mut unparsed, "updated", updated)?;
-        UnparsedMutExt::insert(&mut unparsed, "inReplyTo", in_reply_to)?;
-        UnparsedMutExt::insert(&mut unparsed, "replies", replies)?;
-        UnparsedMutExt::insert(&mut unparsed, "to", to)?;
-        UnparsedMutExt::insert(&mut unparsed, "bto", bto)?;
-        UnparsedMutExt::insert(&mut unparsed, "cc", cc)?;
-        UnparsedMutExt::insert(&mut unparsed, "bcc", bcc)?;
+        inner
+            .insert("attachment", attachment)?
+            .insert("attributedTo", attributed_to)?
+            .insert("audience", audience)?
+            .insert("content", content)?
+            .insert("summary", summary)?
+            .insert("url", url)?
+            .insert("generator", generator)?
+            .insert("image", image)?
+            .insert("location", location)?
+            .insert("startTime", start_time)?
+            .insert("endTime", end_time)?
+            .insert("duration", duration)?
+            .insert("published", published)?
+            .insert("updated", updated)?
+            .insert("inReplyTo", in_reply_to)?
+            .insert("replies", replies)?
+            .insert("to", to)?
+            .insert("bto", bto)?
+            .insert("cc", cc)?
+            .insert("bcc", bcc)?;
 
-        Ok(unparsed)
-    }
-
-    pub fn into_generic(self) -> Result<Object<serde_json::Value>, serde_json::Error>
-    where
-        Kind: serde::ser::Serialize,
-    {
-        self.try_map_kind(serde_json::to_value)
-    }
-
-    pub fn map_kind<NewKind>(self, f: impl Fn(Kind) -> NewKind) -> Object<NewKind> {
-        Object {
-            kind: self.kind.map(f),
-            context: self.context,
-            id: self.id,
-            attachment: self.attachment,
-            attributed_to: self.attributed_to,
-            audience: self.audience,
-            content: self.content,
-            name: self.name,
-            summary: self.summary,
-            url: self.url,
-            media_type: self.media_type,
-            generator: self.generator,
-            image: self.image,
-            location: self.location,
-            preview: self.preview,
-            start_time: self.start_time,
-            end_time: self.end_time,
-            duration: self.duration,
-            published: self.published,
-            updated: self.updated,
-            in_reply_to: self.in_reply_to,
-            replies: self.replies,
-            to: self.to,
-            bto: self.bto,
-            cc: self.cc,
-            bcc: self.bcc,
-            unparsed: self.unparsed,
-        }
-    }
-
-    pub fn try_map_kind<NewKind, E>(
-        self,
-        f: impl Fn(Kind) -> Result<NewKind, E>,
-    ) -> Result<Object<NewKind>, E> {
-        Ok(Object {
-            kind: if let Some(kind) = self.kind {
-                Some((f)(kind)?)
-            } else {
-                None
-            },
-            context: self.context,
-            id: self.id,
-            attachment: self.attachment,
-            attributed_to: self.attributed_to,
-            audience: self.audience,
-            content: self.content,
-            name: self.name,
-            summary: self.summary,
-            url: self.url,
-            media_type: self.media_type,
-            generator: self.generator,
-            image: self.image,
-            location: self.location,
-            preview: self.preview,
-            start_time: self.start_time,
-            end_time: self.end_time,
-            duration: self.duration,
-            published: self.published,
-            updated: self.updated,
-            in_reply_to: self.in_reply_to,
-            replies: self.replies,
-            to: self.to,
-            bto: self.bto,
-            cc: self.cc,
-            bcc: self.bcc,
-            unparsed: self.unparsed,
-        })
-    }
-
-    pub fn extend<Extended>(self) -> Result<Extended, Extended::Error>
-    where
-        Extended: Extends<Self>,
-    {
-        Extended::extends(self)
+        Ok(inner)
     }
 }
 
 impl<Inner> ApObject<Inner> {
     fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
     where
-        Inner: UnparsedMut + traits::Object,
+        Inner: UnparsedMut + markers::Object,
     {
         let shares = inner.remove("shares")?;
         let likes = inner.remove("likes")?;
@@ -2156,7 +1632,7 @@ impl<Inner> ApObject<Inner> {
 
     fn retracting(self) -> Result<Inner, serde_json::Error>
     where
-        Inner: UnparsedMut + traits::Object,
+        Inner: UnparsedMut + markers::Object,
     {
         let ApObject {
             shares,
@@ -2295,33 +1771,33 @@ impl Tombstone {
     }
 }
 
-impl<Kind> Extends<Unparsed> for Object<Kind>
+impl<Kind> Extends<Kind> for Object<Kind>
 where
     Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
 {
     type Error = serde_json::Error;
 
-    fn extends(unparsed: Unparsed) -> Result<Self, Self::Error> {
-        Self::extending(unparsed)
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        Self::extending(base)
     }
 
-    fn retracts(self) -> Result<Unparsed, Self::Error> {
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
         self.retracting()
     }
 }
 
-impl<Kind> TryFrom<Unparsed> for Object<Kind>
+impl<Kind> TryFrom<Base<Kind>> for Object<Kind>
 where
     Kind: serde::de::DeserializeOwned,
 {
     type Error = serde_json::Error;
 
-    fn try_from(unparsed: Unparsed) -> Result<Self, Self::Error> {
-        Self::extending(unparsed)
+    fn try_from(base: Base<Kind>) -> Result<Self, Self::Error> {
+        Self::extending(base)
     }
 }
 
-impl<Kind> TryFrom<Object<Kind>> for Unparsed
+impl<Kind> TryFrom<Object<Kind>> for Base<Kind>
 where
     Kind: serde::ser::Serialize,
 {
@@ -2332,30 +1808,35 @@ where
     }
 }
 
-impl<Inner> Extends<Inner> for ApObject<Inner>
+impl<Inner, Kind> Extends<Kind> for ApObject<Inner>
 where
-    Inner: UnparsedMut + traits::Object,
+    Inner: Extends<Kind, Error = serde_json::Error> + UnparsedMut + markers::Object,
+    Kind: serde::de::DeserializeOwned + serde::ser::Serialize,
 {
     type Error = serde_json::Error;
 
-    fn extends(inner: Inner) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Inner, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
-impl Extends<Object<PlaceType>> for Place {
+impl Extends<PlaceType> for Place {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<PlaceType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<PlaceType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<PlaceType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<PlaceType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -2375,15 +1856,17 @@ impl TryFrom<Place> for Object<PlaceType> {
     }
 }
 
-impl Extends<Object<ProfileType>> for Profile {
+impl Extends<ProfileType> for Profile {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<ProfileType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<ProfileType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<ProfileType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<ProfileType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -2403,15 +1886,17 @@ impl TryFrom<Profile> for Object<ProfileType> {
     }
 }
 
-impl Extends<Object<RelationshipType>> for Relationship {
+impl Extends<RelationshipType> for Relationship {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<RelationshipType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<RelationshipType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<RelationshipType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<RelationshipType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -2431,15 +1916,17 @@ impl TryFrom<Relationship> for Object<RelationshipType> {
     }
 }
 
-impl Extends<Object<TombstoneType>> for Tombstone {
+impl Extends<TombstoneType> for Tombstone {
     type Error = serde_json::Error;
 
-    fn extends(object: Object<TombstoneType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn extends(base: Base<TombstoneType>) -> Result<Self, Self::Error> {
+        let inner = Object::extends(base)?;
+        Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Object<TombstoneType>, Self::Error> {
-        self.retracting()
+    fn retracts(self) -> Result<Base<TombstoneType>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
     }
 }
 
@@ -2461,7 +1948,7 @@ impl TryFrom<Tombstone> for Object<TombstoneType> {
 
 impl<Kind> UnparsedMut for Object<Kind> {
     fn unparsed_mut(&mut self) -> &mut Unparsed {
-        &mut self.unparsed
+        self.inner.unparsed_mut()
     }
 }
 
@@ -2498,230 +1985,257 @@ impl UnparsedMut for Tombstone {
     }
 }
 
-impl From<Object<serde_json::Value>> for AnyObject {
-    fn from(o: Object<serde_json::Value>) -> Self {
-        Self::from_object(o)
+impl<Kind> markers::Base for Object<Kind> {}
+impl<Kind> markers::Object for Object<Kind> {}
+
+impl<Inner> markers::Base for ApObject<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for ApObject<Inner> where Inner: markers::Object {}
+
+impl markers::Base for Place {}
+impl markers::Object for Place {}
+
+impl markers::Base for Profile {}
+impl markers::Object for Profile {}
+
+impl markers::Base for Relationship {}
+impl markers::Object for Relationship {}
+
+impl markers::Base for Tombstone {}
+impl markers::Object for Tombstone {}
+
+impl<T, Kind> ObjectExt<Kind> for T where T: AsObject<Kind> {}
+impl<T, Inner> ApObjectExt<Inner> for T where T: AsApObject<Inner> {}
+impl<T> PlaceExt for T where T: AsPlace {}
+impl<T> ProfileExt for T where T: AsProfile {}
+impl<T> RelationshipExt for T where T: AsRelationship {}
+impl<T> TombstoneExt for T where T: AsTombstone {}
+
+impl<Kind> AsBase<Kind> for Object<Kind> {
+    fn base_ref(&self) -> &Base<Kind> {
+        &self.inner
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        &mut self.inner
     }
 }
 
-impl From<XsdAnyUri> for AnyObject {
-    fn from(id: XsdAnyUri) -> Self {
-        Self::from_xsd_any_uri(id)
-    }
-}
-
-impl From<XsdString> for AnyObject {
-    fn from(xsd_string: XsdString) -> Self {
-        Self::from_xsd_string(xsd_string)
-    }
-}
-
-impl From<Object<serde_json::Value>> for OneOrMany<AnyObject> {
-    fn from(object: Object<serde_json::Value>) -> Self {
-        Self::from_object(object)
-    }
-}
-
-impl From<XsdAnyUri> for OneOrMany<AnyObject> {
-    fn from(xsd_any_uri: XsdAnyUri) -> Self {
-        Self::from_xsd_any_uri(xsd_any_uri)
-    }
-}
-
-impl From<XsdString> for OneOrMany<AnyObject> {
-    fn from(xsd_string: XsdString) -> Self {
-        Self::from_xsd_string(xsd_string)
-    }
-}
-
-impl<Kind> traits::Base for Object<Kind> {}
-impl<Kind> traits::Object for Object<Kind> {}
-
-impl<Inner> traits::Base for ApObject<Inner> where Inner: traits::Base {}
-impl<Inner> traits::Object for ApObject<Inner> where Inner: traits::Object {}
-
-impl traits::Base for Place {}
-impl traits::Object for Place {}
-
-impl traits::Base for Profile {}
-impl traits::Object for Profile {}
-
-impl traits::Base for Relationship {}
-impl traits::Object for Relationship {}
-
-impl traits::Base for Tombstone {}
-impl traits::Object for Tombstone {}
-
-impl<T, Kind> ObjectRefExt<Kind> for T where T: ObjectRef<Kind> {}
-impl<T, Kind> ObjectMutExt<Kind> for T where T: ObjectMut<Kind> {}
-
-impl<T, Inner> ApObjectRefExt<Inner> for T where T: ApObjectRef<Inner> {}
-impl<T, Inner> ApObjectMutExt<Inner> for T where T: ApObjectMut<Inner> {}
-
-impl<T> PlaceRefExt for T where T: PlaceRef {}
-impl<T> PlaceMutExt for T where T: PlaceMut {}
-
-impl<T> ProfileRefExt for T where T: ProfileRef {}
-impl<T> ProfileMutExt for T where T: ProfileMut {}
-
-impl<T> RelationshipRefExt for T where T: RelationshipRef {}
-impl<T> RelationshipMutExt for T where T: RelationshipMut {}
-
-impl<T> TombstoneRefExt for T where T: TombstoneRef {}
-impl<T> TombstoneMutExt for T where T: TombstoneMut {}
-
-impl<Kind> ObjectRef<Kind> for Object<Kind> {
+impl<Kind> AsObject<Kind> for Object<Kind> {
     fn object_ref(&self) -> &Object<Kind> {
         self
     }
-}
-impl<Kind> ObjectMut<Kind> for Object<Kind> {
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self
     }
 }
 
-impl<Inner, Kind> ObjectRef<Kind> for ApObject<Inner>
+impl<Inner, Kind> AsBase<Kind> for ApObject<Inner>
 where
-    Inner: ObjectRef<Kind>,
+    Inner: AsBase<Kind>,
+{
+    fn base_ref(&self) -> &Base<Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner, Kind> AsObject<Kind> for ApObject<Inner>
+where
+    Inner: AsObject<Kind>,
 {
     fn object_ref(&self) -> &Object<Kind> {
         self.inner.object_ref()
     }
-}
-impl<Inner, Kind> ObjectMut<Kind> for ApObject<Inner>
-where
-    Inner: ObjectMut<Kind>,
-{
+
     fn object_mut(&mut self) -> &mut Object<Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Inner> ApObjectRef<Inner> for ApObject<Inner>
+impl<Inner> AsApObject<Inner> for ApObject<Inner>
 where
-    Inner: traits::Object,
+    Inner: markers::Object,
 {
     fn ap_object_ref(&self) -> &ApObject<Inner> {
         self
     }
-}
-impl<Inner> ApObjectMut<Inner> for ApObject<Inner>
-where
-    Inner: traits::Object,
-{
+
     fn ap_object_mut(&mut self) -> &mut ApObject<Inner> {
         self
     }
 }
 
-impl<Inner> PlaceRef for ApObject<Inner>
+impl<Inner> AsPlace for ApObject<Inner>
 where
-    Inner: PlaceRef,
+    Inner: AsPlace,
 {
     fn place_ref(&self) -> &Place {
         self.inner.place_ref()
     }
-}
-impl<Inner> PlaceMut for ApObject<Inner>
-where
-    Inner: PlaceMut,
-{
+
     fn place_mut(&mut self) -> &mut Place {
         self.inner.place_mut()
     }
 }
 
-impl<Inner> ProfileRef for ApObject<Inner>
+impl<Inner> AsProfile for ApObject<Inner>
 where
-    Inner: ProfileRef,
+    Inner: AsProfile,
 {
     fn profile_ref(&self) -> &Profile {
         self.inner.profile_ref()
     }
-}
-impl<Inner> ProfileMut for ApObject<Inner>
-where
-    Inner: ProfileMut,
-{
+
     fn profile_mut(&mut self) -> &mut Profile {
         self.inner.profile_mut()
     }
 }
 
-impl<Inner> RelationshipRef for ApObject<Inner>
+impl<Inner> AsRelationship for ApObject<Inner>
 where
-    Inner: RelationshipRef,
+    Inner: AsRelationship,
 {
     fn relationship_ref(&self) -> &Relationship {
         self.inner.relationship_ref()
     }
-}
-impl<Inner> RelationshipMut for ApObject<Inner>
-where
-    Inner: RelationshipMut,
-{
+
     fn relationship_mut(&mut self) -> &mut Relationship {
         self.inner.relationship_mut()
     }
 }
 
-impl<Inner> TombstoneRef for ApObject<Inner>
+impl<Inner> AsTombstone for ApObject<Inner>
 where
-    Inner: TombstoneRef,
+    Inner: AsTombstone,
 {
     fn tombstone_ref(&self) -> &Tombstone {
         self.inner.tombstone_ref()
     }
-}
-impl<Inner> TombstoneMut for ApObject<Inner>
-where
-    Inner: TombstoneMut,
-{
+
     fn tombstone_mut(&mut self) -> &mut Tombstone {
         self.inner.tombstone_mut()
     }
 }
 
-impl PlaceRef for Place {
+impl AsBase<PlaceType> for Place {
+    fn base_ref(&self) -> &Base<PlaceType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<PlaceType> {
+        self.inner.base_mut()
+    }
+}
+
+impl AsObject<PlaceType> for Place {
+    fn object_ref(&self) -> &Object<PlaceType> {
+        &self.inner
+    }
+
+    fn object_mut(&mut self) -> &mut Object<PlaceType> {
+        &mut self.inner
+    }
+}
+
+impl AsPlace for Place {
     fn place_ref(&self) -> &Place {
         self
     }
-}
-impl PlaceMut for Place {
+
     fn place_mut(&mut self) -> &mut Place {
         self
     }
 }
 
-impl ProfileRef for Profile {
+impl AsBase<ProfileType> for Profile {
+    fn base_ref(&self) -> &Base<ProfileType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<ProfileType> {
+        self.inner.base_mut()
+    }
+}
+
+impl AsObject<ProfileType> for Profile {
+    fn object_ref(&self) -> &Object<ProfileType> {
+        &self.inner
+    }
+
+    fn object_mut(&mut self) -> &mut Object<ProfileType> {
+        &mut self.inner
+    }
+}
+
+impl AsProfile for Profile {
     fn profile_ref(&self) -> &Profile {
         self
     }
-}
-impl ProfileMut for Profile {
+
     fn profile_mut(&mut self) -> &mut Profile {
         self
     }
 }
 
-impl RelationshipRef for Relationship {
+impl AsBase<RelationshipType> for Relationship {
+    fn base_ref(&self) -> &Base<RelationshipType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<RelationshipType> {
+        self.inner.base_mut()
+    }
+}
+
+impl AsObject<RelationshipType> for Relationship {
+    fn object_ref(&self) -> &Object<RelationshipType> {
+        &self.inner
+    }
+
+    fn object_mut(&mut self) -> &mut Object<RelationshipType> {
+        &mut self.inner
+    }
+}
+
+impl AsRelationship for Relationship {
     fn relationship_ref(&self) -> &Relationship {
         self
     }
-}
-impl RelationshipMut for Relationship {
+
     fn relationship_mut(&mut self) -> &mut Relationship {
         self
     }
 }
 
-impl TombstoneRef for Tombstone {
+impl AsBase<TombstoneType> for Tombstone {
+    fn base_ref(&self) -> &Base<TombstoneType> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<TombstoneType> {
+        self.inner.base_mut()
+    }
+}
+
+impl AsObject<TombstoneType> for Tombstone {
+    fn object_ref(&self) -> &Object<TombstoneType> {
+        &self.inner
+    }
+
+    fn object_mut(&mut self) -> &mut Object<TombstoneType> {
+        &mut self.inner
+    }
+}
+
+impl AsTombstone for Tombstone {
     fn tombstone_ref(&self) -> &Tombstone {
         self
     }
-}
-impl TombstoneMut for Tombstone {
+
     fn tombstone_mut(&mut self) -> &mut Tombstone {
         self
     }
diff --git a/src/primitives.rs b/src/primitives.rs
index 735e8fa..657cdd7 100644
--- a/src/primitives.rs
+++ b/src/primitives.rs
@@ -5,10 +5,6 @@ pub use activitystreams::primitives::{
     XsdNonNegativeInteger, XsdString,
 };
 
-#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
-#[serde(transparent)]
-pub struct Unparsed(std::collections::HashMap<String, serde_json::Value>);
-
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(transparent)]
 pub struct AnyString(Either<XsdString, RdfLangString>);
@@ -19,16 +15,6 @@ pub type Unit = Either<Length, XsdString>;
 #[serde(transparent)]
 pub struct OneOrMany<T>(pub Either<T, Vec<T>>);
 
-impl Unparsed {
-    pub(crate) fn remove(&mut self, key: &str) -> serde_json::Value {
-        self.0.remove(key).unwrap_or(serde_json::Value::Null)
-    }
-
-    pub(crate) fn insert(&mut self, key: String, value: serde_json::Value) {
-        self.0.insert(key, value);
-    }
-}
-
 impl AnyString {
     pub fn as_xsd_string(&self) -> Option<&XsdString> {
         self.0.as_ref().left()
@@ -185,14 +171,6 @@ impl<T> OneOrMany<T> {
     }
 }
 
-impl crate::traits::Base for Unparsed {}
-
-impl crate::traits::UnparsedMut for Unparsed {
-    fn unparsed_mut(&mut self) -> &mut Unparsed {
-        self
-    }
-}
-
 impl<T> From<T> for OneOrMany<T> {
     fn from(t: T) -> Self {
         OneOrMany::from_one(t)
diff --git a/src/traits.rs b/src/unparsed.rs
similarity index 53%
rename from src/traits.rs
rename to src/unparsed.rs
index 090c939..7b5d388 100644
--- a/src/traits.rs
+++ b/src/unparsed.rs
@@ -1,8 +1,3 @@
-use crate::primitives::Unparsed;
-pub use activitystreams::{
-    Activity, Actor, Base, Collection, CollectionPage, IntransitiveActivity, Link, Object,
-};
-
 pub trait UnparsedMut {
     fn unparsed_mut(&mut self) -> &mut Unparsed;
 }
@@ -25,12 +20,24 @@ pub trait UnparsedMutExt: UnparsedMut {
     }
 }
 
-pub trait Extends<T>: Sized {
-    type Error: std::error::Error;
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
+#[serde(transparent)]
+pub struct Unparsed(std::collections::HashMap<String, serde_json::Value>);
 
-    fn extends(t: T) -> Result<Self, Self::Error>;
+impl Unparsed {
+    pub(crate) fn remove(&mut self, key: &str) -> serde_json::Value {
+        self.0.remove(key).unwrap_or(serde_json::Value::Null)
+    }
 
-    fn retracts(self) -> Result<T, Self::Error>;
+    pub(crate) fn insert(&mut self, key: String, value: serde_json::Value) {
+        self.0.insert(key, value);
+    }
+}
+
+impl UnparsedMut for Unparsed {
+    fn unparsed_mut(&mut self) -> &mut Unparsed {
+        self
+    }
 }
 
 impl<T> UnparsedMutExt for T where T: UnparsedMut {}