From a0fef3abc46c4817d6eddd5b5a66b71528ec8463 Mon Sep 17 00:00:00 2001
From: asonix <asonix@asonix.dog>
Date: Tue, 6 Dec 2022 17:36:34 -0600
Subject: [PATCH] Refactor Kind out of trait signatures

---
 Cargo.toml                                 |    2 +-
 activitystreams-ext/Cargo.toml             |    4 +-
 activitystreams-ext/examples/public_key.rs |    6 +-
 activitystreams-ext/src/ext1.rs            |  151 +-
 activitystreams-ext/src/ext2.rs            |  151 +-
 activitystreams-ext/src/ext3.rs            |  151 +-
 activitystreams-ext/src/ext4.rs            |  151 +-
 activitystreams-ext/src/lib.rs             |   50 +-
 examples/handle_incoming.rs                |    2 +-
 src/activity.rs                            | 3153 +++++++++++---------
 src/actor.rs                               |   82 +-
 src/base.rs                                |   85 +-
 src/collection.rs                          |  154 +-
 src/lib.rs                                 |   14 +-
 src/link.rs                                |   45 +-
 src/markers.rs                             |    4 +-
 src/object.rs                              |  154 +-
 src/unparsed.rs                            |   29 +-
 18 files changed, 2454 insertions(+), 1934 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index b813b08..7ca7a5c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams"
 description = "A set of core types and traits for activitystreams data"
-version = "0.7.0-alpha.20"
+version = "0.7.0-alpha.21"
 license = "GPL-3.0"
 authors = ["asonix <asonix@asonix.dog>"]
 repository = "https://git.asonix.dog/asonix/activitystreams"
diff --git a/activitystreams-ext/Cargo.toml b/activitystreams-ext/Cargo.toml
index d1ed49d..f4ef567 100644
--- a/activitystreams-ext/Cargo.toml
+++ b/activitystreams-ext/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams-ext"
 description = "Extension types for the ActivityStreams crate"
-version = "0.1.0-alpha.2"
+version = "0.1.0-alpha.3"
 license = "GPL-3.0"
 authors = ["asonix <asonix@asonix.dog>"]
 repository = "https://git.asonix.dog/Aardwolf/activitystreams"
@@ -13,7 +13,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-activitystreams = { version = "0.7.0-alpha.3", path = ".." }
+activitystreams = { version = "0.7.0-alpha.21", path = ".." }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
diff --git a/activitystreams-ext/examples/public_key.rs b/activitystreams-ext/examples/public_key.rs
index 0478c7a..4724f85 100644
--- a/activitystreams-ext/examples/public_key.rs
+++ b/activitystreams-ext/examples/public_key.rs
@@ -1,10 +1,10 @@
 use activitystreams::{
     actor::{ApActor, Person},
     context,
+    iri_string::types::IriString,
     prelude::*,
     security,
     unparsed::UnparsedMutExt,
-    url::Url,
 };
 use activitystreams_ext::{Ext1, UnparsedExtension};
 
@@ -17,8 +17,8 @@ pub struct PublicKey {
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PublicKeyInner {
-    id: Url,
-    owner: Url,
+    id: IriString,
+    owner: IriString,
     public_key_pem: String,
 }
 
diff --git a/activitystreams-ext/src/ext1.rs b/activitystreams-ext/src/ext1.rs
index c0d99df..79ae5ff 100644
--- a/activitystreams-ext/src/ext1.rs
+++ b/activitystreams-ext/src/ext1.rs
@@ -1,15 +1,15 @@
 use crate::Ext1;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A> markers::Base for Ext1<Inner, A> where Inner: markers::Base {}
@@ -23,28 +23,32 @@ impl<Inner, A> markers::IntransitiveActivity for Ext1<Inner, A> where
 {
 }
 
-impl<Inner, A, Kind> AsBase<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsBase for Ext1<Inner, A>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, Kind> AsObject<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsObject for Ext1<Inner, A>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -62,28 +66,32 @@ where
     }
 }
 
-impl<Inner, A, Kind> AsCollection<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsCollection for Ext1<Inner, A>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, Kind> AsCollectionPage<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsCollectionPage for Ext1<Inner, A>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -101,89 +109,108 @@ where
     }
 }
 
-impl<Inner, A, Kind> AsActivity<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsActivity for Ext1<Inner, A>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A> ActorAndObjectRef for Ext1<Inner, A>
+impl<Inner, A> AsActivityActor for Ext1<Inner, A>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A> TargetRef for Ext1<Inner, A>
+impl<Inner, A> AsActivityObject for Ext1<Inner, A>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A> OriginRef for Ext1<Inner, A>
+impl<Inner, A> AsTarget for Ext1<Inner, A>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A> OptTargetRef for Ext1<Inner, A>
+impl<Inner, A> AsOrigin for Ext1<Inner, A>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A> OptOriginRef for Ext1<Inner, A>
+impl<Inner, A> AsOptTarget for Ext1<Inner, A>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A> AsOptOrigin for Ext1<Inner, A>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 
diff --git a/activitystreams-ext/src/ext2.rs b/activitystreams-ext/src/ext2.rs
index f76646c..16abb2b 100644
--- a/activitystreams-ext/src/ext2.rs
+++ b/activitystreams-ext/src/ext2.rs
@@ -1,15 +1,15 @@
 use crate::Ext2;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B> markers::Base for Ext2<Inner, A, B> where Inner: markers::Base {}
@@ -23,28 +23,32 @@ impl<Inner, A, B> markers::IntransitiveActivity for Ext2<Inner, A, B> where
 {
 }
 
-impl<Inner, A, B, Kind> AsBase<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsBase for Ext2<Inner, A, B>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, Kind> AsObject<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsObject for Ext2<Inner, A, B>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -62,28 +66,32 @@ where
     }
 }
 
-impl<Inner, A, B, Kind> AsCollection<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsCollection for Ext2<Inner, A, B>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, Kind> AsCollectionPage<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsCollectionPage for Ext2<Inner, A, B>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -101,89 +109,108 @@ where
     }
 }
 
-impl<Inner, A, B, Kind> AsActivity<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivity for Ext2<Inner, A, B>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B> ActorAndObjectRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivityActor for Ext2<Inner, A, B>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B> TargetRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivityObject for Ext2<Inner, A, B>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B> OriginRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsTarget for Ext2<Inner, A, B>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B> OptTargetRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsOrigin for Ext2<Inner, A, B>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B> OptOriginRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsOptTarget for Ext2<Inner, A, B>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B> AsOptOrigin for Ext2<Inner, A, B>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 
diff --git a/activitystreams-ext/src/ext3.rs b/activitystreams-ext/src/ext3.rs
index bad78eb..dbcfd47 100644
--- a/activitystreams-ext/src/ext3.rs
+++ b/activitystreams-ext/src/ext3.rs
@@ -1,15 +1,15 @@
 use crate::Ext3;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B, C> markers::Base for Ext3<Inner, A, B, C> where Inner: markers::Base {}
@@ -26,28 +26,32 @@ impl<Inner, A, B, C> markers::IntransitiveActivity for Ext3<Inner, A, B, C> wher
 {
 }
 
-impl<Inner, A, B, C, Kind> AsBase<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsBase for Ext3<Inner, A, B, C>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, C, Kind> AsObject<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsObject for Ext3<Inner, A, B, C>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -65,28 +69,32 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind> AsCollection<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsCollection for Ext3<Inner, A, B, C>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, C, Kind> AsCollectionPage<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsCollectionPage for Ext3<Inner, A, B, C>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -104,89 +112,108 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind> AsActivity<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivity for Ext3<Inner, A, B, C>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B, C> ActorAndObjectRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivityActor for Ext3<Inner, A, B, C>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B, C> TargetRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivityObject for Ext3<Inner, A, B, C>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B, C> OriginRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsTarget for Ext3<Inner, A, B, C>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B, C> OptTargetRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsOrigin for Ext3<Inner, A, B, C>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B, C> OptOriginRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsOptTarget for Ext3<Inner, A, B, C>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B, C> AsOptOrigin for Ext3<Inner, A, B, C>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 
diff --git a/activitystreams-ext/src/ext4.rs b/activitystreams-ext/src/ext4.rs
index a734471..62fdb36 100644
--- a/activitystreams-ext/src/ext4.rs
+++ b/activitystreams-ext/src/ext4.rs
@@ -1,15 +1,15 @@
 use crate::Ext4;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B, C, D> markers::Base for Ext4<Inner, A, B, C, D> where Inner: markers::Base {}
@@ -29,28 +29,32 @@ impl<Inner, A, B, C, D> markers::IntransitiveActivity for Ext4<Inner, A, B, C, D
 {
 }
 
-impl<Inner, A, B, C, D, Kind> AsBase<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsBase for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsObject<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsObject for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -68,28 +72,32 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsCollection<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsCollection for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsCollectionPage<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsCollectionPage for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -107,89 +115,108 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsActivity<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivity for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B, C, D> ActorAndObjectRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivityActor for Ext4<Inner, A, B, C, D>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B, C, D> TargetRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivityObject for Ext4<Inner, A, B, C, D>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OriginRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsTarget for Ext4<Inner, A, B, C, D>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OptTargetRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsOrigin for Ext4<Inner, A, B, C, D>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OptOriginRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsOptTarget for Ext4<Inner, A, B, C, D>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B, C, D> AsOptOrigin for Ext4<Inner, A, B, C, D>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 
diff --git a/activitystreams-ext/src/lib.rs b/activitystreams-ext/src/lib.rs
index 24bd6c7..d226621 100644
--- a/activitystreams-ext/src/lib.rs
+++ b/activitystreams-ext/src/lib.rs
@@ -1,10 +1,10 @@
 //! # An extension API for activitystreams
 //! _This crate provides Ext1, Ext2, Ext3, and Ext4 for adding extensions to ActivityStreams types_
 //!
-//! - Find the code on [git.asonix.dog](https://git.asonix.dog/Aardwolf/activitystreams)
+//! - Find the code on [git.asonix.dog](https://git.asonix.dog/asonix/activitystreams)
 //! - Read the docs on [docs.rs](https://docs.rs/activitystreams-ext)
 //! - Join the matrix channel at [#activitypub:asonix.dog](https://matrix.to/#/!fAEcHyTUdAaKCzIKCt:asonix.dog?via=asonix.dog&via=matrix.org&via=t2bot.io)
-//! - Hit me up on [mastodon](https://asonix.dog/@asonix)
+//! - Hit me up on [mastodon](https://masto.asonix.dog/@asonix)
 //!
 //! ## Usage
 //!
@@ -23,7 +23,7 @@
 //!     prelude::*,
 //!     security,
 //!     unparsed::UnparsedMutExt,
-//!     url::Url,
+//!     iri_string::types::IriString,
 //! };
 //! use activitystreams_ext::{Ext1, UnparsedExtension};
 //!
@@ -36,8 +36,8 @@
 //! #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 //! #[serde(rename_all = "camelCase")]
 //! pub struct PublicKeyInner {
-//!     id: Url,
-//!     owner: Url,
+//!     id: IriString,
+//!     owner: IriString,
 //!     public_key_pem: String,
 //! }
 //!
@@ -264,22 +264,24 @@ impl<Inner, A, B, C, D> Ext4<Inner, A, B, C, D> {
     }
 }
 
-impl<Inner, A, Kind, Error> Extends<Kind> for Ext1<Inner, A>
+impl<Inner, A, Error> Extends for Ext1<Inner, A>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
 
         Ok(Ext1 { inner, ext_one })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext1 { mut inner, ext_one } = self;
 
         ext_one.try_into_unparsed(&mut inner)?;
@@ -287,16 +289,18 @@ where
     }
 }
 
-impl<Inner, A, B, Kind, Error> Extends<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B, Error> Extends for Ext2<Inner, A, B>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -308,7 +312,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext2 {
             mut inner,
             ext_one,
@@ -321,17 +325,19 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind, Error> Extends<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C, Error> Extends for Ext3<Inner, A, B, C>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     C: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -345,7 +351,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext3 {
             mut inner,
             ext_one,
@@ -360,18 +366,20 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind, Error> Extends<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D, Error> Extends for Ext4<Inner, A, B, C, D>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     C: UnparsedExtension<Inner, Error = Error>,
     D: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -387,7 +395,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext4 {
             mut inner,
             ext_one,
diff --git a/examples/handle_incoming.rs b/examples/handle_incoming.rs
index 0ca2f2a..b5bc72d 100644
--- a/examples/handle_incoming.rs
+++ b/examples/handle_incoming.rs
@@ -33,7 +33,7 @@ pub fn handle_activity(activity: AcceptedActivity) -> Result<(), anyhow::Error>
     Ok(())
 }
 
-static EXAMPLE_JSON: &str = r#"{"actor":"https://asonix.dog/users/asonix","object":"https://asonix.dog/users/asonix/posts/1","type":"Announce"}"#;
+static EXAMPLE_JSON: &str = r#"{"id":"https://asonix.dog/activities/1","actor":"https://asonix.dog/users/asonix","object":"https://asonix.dog/users/asonix/posts/1","type":"Announce"}"#;
 
 fn main() -> Result<(), anyhow::Error> {
     handle_activity(serde_json::from_str(EXAMPLE_JSON)?)
diff --git a/src/activity.rs b/src/activity.rs
index f757079..fc2c498 100644
--- a/src/activity.rs
+++ b/src/activity.rs
@@ -42,77 +42,85 @@ use self::kind::*;
 /// Implementation trait for deriving Activity methods for a type
 ///
 /// Any type implementing AsObject will automatically gain methods provided by ActivityExt
-pub trait AsActivity<Kind>: markers::Activity {
+pub trait AsActivity: markers::Activity {
+    type Kind;
+
     /// Immutable borrow of `Activity<Kind>`
-    fn activity_ref(&self) -> &Activity<Kind>;
+    fn activity_ref(&self) -> &Activity<Self::Kind>;
 
     /// Mutable borrow of `Activity<Kind>`
-    fn activity_mut(&mut self) -> &mut Activity<Kind>;
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind>;
 }
 
 /// Implementation trait for deriving Actor and Object methods for a type
 ///
-/// Any type implementing ActorAndObjectRef will automatically gain methods provided by
-/// `ActorAndObjectRefExt`
-pub trait ActorAndObjectRef: markers::Activity {
-    /// Immutable borrow of actor field
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase>;
+/// Any type implementing AsActivityActor will automatically gain methods provided by
+/// `AsActivityActorExt`
+pub trait AsActivityActor: markers::Activity {
+    type Inner;
 
-    /// Immutable borrow of object field
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase>;
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner>;
 
-    /// Mutable borrow of actor field
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner>;
+}
 
-    /// Mutable borrow of object field
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
+/// Implementation trait for deriving Actor and Object methods for a type
+///
+/// Any type implementing AsActivityObject will automatically gain methods provided by
+/// `AsActivityObjectExt`
+pub trait AsActivityObject: markers::Activity {
+    type Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner>;
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner>;
 }
 
 /// Implementation trait for deriving Target methods for a type
 ///
-/// Any type implementing TargetRef will automatically gain methods provided by `TargetRefExt`
-pub trait TargetRef: markers::Activity {
-    /// Immutable borrow of target field
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase>;
+/// Any type implementing AsTarget will automatically gain methods provided by `AsTargetExt`
+pub trait AsTarget: markers::Activity {
+    type Inner;
 
-    /// Mutable borrow of target field
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
+    fn target_ref(&self) -> &Target<Self::Inner>;
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner>;
 }
 
 /// Implementation trait for deriving Origin methods for a type
 ///
-/// Any type implementing OriginRef will automatically gain methods provided by
-/// `OriginRefExt`
-pub trait OriginRef: markers::Activity {
-    /// Immutable borrow of origin field
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase>;
+/// Any type implementing AsOrigin will automatically gain methods provided by
+/// `AsOriginExt`
+pub trait AsOrigin: markers::Activity {
+    type Inner;
 
-    /// Mutable borrow of origin field
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase>;
+    fn origin_ref(&self) -> &Origin<Self::Inner>;
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner>;
 }
 
 /// Implementation trait for deriving Target methods for a type
 ///
-/// Any type implementing OptTargetRef will automatically gain methods provided by
-/// `OptTargetRefExt`
-pub trait OptTargetRef: markers::Activity {
-    /// Immutable borrow of target field
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>>;
+/// Any type implementing AsOptTarget will automatically gain methods provided by
+/// `AsOptTargetExt`
+pub trait AsOptTarget: markers::Activity {
+    type Inner;
 
-    /// Mutable borrow of target field
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>;
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner>;
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner>;
 }
 
 /// Implementation trait for deriving Origin methods for a type
 ///
-/// Any type implementing OptOriginRef will automatically gain methods provided by
-/// `OptOriginRefExt`
-pub trait OptOriginRef: markers::Activity {
-    /// Immutable borrow of origin field
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>>;
+/// Any type implementing AsOptOrigin will automatically gain methods provided by
+/// `AsOptOriginExt`
+pub trait AsOptOrigin: markers::Activity {
+    type Inner;
 
-    /// Mutable borrow of origin field
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>;
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner>;
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner>;
 }
 
 /// Implementation trait for deriving Question methods for a type
@@ -133,7 +141,7 @@ pub trait AsQuestion: markers::Activity {
 ///
 /// Documentation for the fields related to these methods can be found on the `Activity`
 /// struct
-pub trait ActivityExt<Kind>: AsActivity<Kind> {
+pub trait ActivityExt: AsActivity {
     /// Fetch the result for the current activity
     ///
     /// ```rust
@@ -148,7 +156,7 @@ pub trait ActivityExt<Kind>: AsActivity<Kind> {
     /// ```
     fn result<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.activity_ref().result.as_ref()
     }
@@ -284,7 +292,7 @@ pub trait ActivityExt<Kind>: AsActivity<Kind> {
     /// ```
     fn instrument<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.activity_ref().instrument.as_ref()
     }
@@ -411,7 +419,7 @@ pub trait ActivityExt<Kind>: AsActivity<Kind> {
 ///
 /// Documentation for the fields related to these methods can be found on the
 /// `ActorAndObject` struct
-pub trait ActorAndObjectRefExt: ActorAndObjectRef {
+pub trait AsActivityActorExt: AsActivityActor {
     /// Fetch the actor for the current activity
     ///
     /// ```rust
@@ -423,9 +431,9 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     /// let actor_ref = create.actor();
     /// println!("{:?}", actor_ref);
     /// ```
-    fn actor<Kind>(&self) -> Result<&OneOrMany<AnyBase>, CheckError>
+    fn actor(&self) -> Result<&OneOrMany<AnyBase>, CheckError>
     where
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         let actor = self.actor_unchecked();
 
@@ -449,7 +457,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     /// println!("{:?}", actor_ref);
     /// ```
     fn actor_unchecked(&self) -> &OneOrMany<AnyBase> {
-        self.actor_field_ref()
+        &self.activity_actor_ref().actor
     }
 
     /// Check if the actor's ID is `id`
@@ -488,7 +496,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     where
         T: Into<AnyBase>,
     {
-        *self.actor_field_mut() = actor.into().into();
+        self.activity_actor_mut().actor = actor.into().into();
         self
     }
 
@@ -515,7 +523,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.actor_field_mut() = v.into();
+        self.activity_actor_mut().actor = v.into();
         self
     }
 
@@ -539,10 +547,12 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     where
         T: Into<AnyBase>,
     {
-        self.actor_field_mut().add(actor.into());
+        self.activity_actor_mut().actor.add(actor.into());
         self
     }
+}
 
+pub trait AsActivityObjectExt: AsActivityObject {
     /// Fetch the object for the current activity
     ///
     /// ```rust
@@ -554,9 +564,9 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     /// let object_ref = create.object();
     /// println!("{:?}", object_ref);
     /// ```
-    fn object<Kind>(&self) -> Result<&OneOrMany<AnyBase>, CheckError>
+    fn object(&self) -> Result<&OneOrMany<AnyBase>, CheckError>
     where
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         let object = self.object_unchecked();
 
@@ -580,7 +590,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     /// println!("{:?}", object_ref);
     /// ```
     fn object_unchecked(&self) -> &OneOrMany<AnyBase> {
-        self.object_field_ref()
+        &self.activity_object_ref().object
     }
 
     /// Check if the object's ID is `id`
@@ -619,7 +629,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     where
         T: Into<AnyBase>,
     {
-        *self.object_field_mut() = object.into().into();
+        self.activity_object_mut().object = object.into().into();
         self
     }
 
@@ -646,7 +656,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.object_field_mut() = v.into();
+        self.activity_object_mut().object = v.into();
         self
     }
 
@@ -670,7 +680,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
     where
         T: Into<AnyBase>,
     {
-        self.object_field_mut().add(object.into());
+        self.activity_object_mut().object.add(object.into());
         self
     }
 }
@@ -678,7 +688,7 @@ pub trait ActorAndObjectRefExt: ActorAndObjectRef {
 /// Helper methods for interacting with Activity types with a target field
 ///
 /// Documentation for the target field can be found on the `Invite` struct
-pub trait TargetRefExt: TargetRef {
+pub trait AsTargetExt: AsTarget {
     /// Fetch the target for the current activity
     ///
     /// ```rust
@@ -691,7 +701,7 @@ pub trait TargetRefExt: TargetRef {
     /// println!("{:?}", target_ref);
     /// ```
     fn target(&self) -> &OneOrMany<AnyBase> {
-        self.target_field_ref()
+        &self.target_ref().target
     }
 
     /// Set the target for the current activity
@@ -712,7 +722,7 @@ pub trait TargetRefExt: TargetRef {
     where
         T: Into<AnyBase>,
     {
-        *self.target_field_mut() = target.into().into();
+        self.target_mut().target = target.into().into();
         self
     }
 
@@ -739,7 +749,7 @@ pub trait TargetRefExt: TargetRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.target_field_mut() = v.into();
+        self.target_mut().target = v.into();
         self
     }
 
@@ -763,7 +773,7 @@ pub trait TargetRefExt: TargetRef {
     where
         T: Into<AnyBase>,
     {
-        self.target_field_mut().add(target.into());
+        self.target_mut().target.add(target.into());
         self
     }
 }
@@ -771,7 +781,7 @@ pub trait TargetRefExt: TargetRef {
 /// Helper methods for interacting with Activity types with an origin
 ///
 /// Documentation for the origin field can be found on the `Arrive` struct
-pub trait OriginRefExt: OriginRef {
+pub trait AsOriginExt: AsOrigin {
     /// Fetch the origin for the current activity
     ///
     /// ```rust
@@ -784,7 +794,7 @@ pub trait OriginRefExt: OriginRef {
     /// println!("{:?}", origin_ref);
     /// ```
     fn origin(&self) -> &OneOrMany<AnyBase> {
-        self.origin_field_ref()
+        &self.origin_ref().origin
     }
 
     /// Set the origin for the current activity
@@ -805,7 +815,7 @@ pub trait OriginRefExt: OriginRef {
     where
         T: Into<AnyBase>,
     {
-        *self.origin_field_mut() = origin.into().into();
+        self.origin_mut().origin = origin.into().into();
         self
     }
 
@@ -832,7 +842,7 @@ pub trait OriginRefExt: OriginRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.origin_field_mut() = v.into();
+        self.origin_mut().origin = v.into();
         self
     }
 
@@ -856,7 +866,7 @@ pub trait OriginRefExt: OriginRef {
     where
         T: Into<AnyBase>,
     {
-        self.origin_field_mut().add(origin.into());
+        self.origin_mut().origin.add(origin.into());
         self
     }
 }
@@ -864,8 +874,8 @@ pub trait OriginRefExt: OriginRef {
 /// Helper methods for interacting with Activity types with an optional target field
 ///
 /// Documentation for the target field can be found on the
-/// `ActorAndObjectOptTarget` struct
-pub trait OptTargetRefExt: OptTargetRef {
+/// `OptTarget` struct
+pub trait AsOptTargetExt: AsOptTarget {
     /// Fetch the target for the current activity
     ///
     /// ```rust
@@ -879,7 +889,7 @@ pub trait OptTargetRefExt: OptTargetRef {
     /// }
     /// ```
     fn target(&self) -> Option<&OneOrMany<AnyBase>> {
-        self.target_field_ref().as_ref()
+        self.opt_target_ref().target.as_ref()
     }
 
     /// Set the target for the current activity
@@ -900,7 +910,7 @@ pub trait OptTargetRefExt: OptTargetRef {
     where
         T: Into<AnyBase>,
     {
-        *self.target_field_mut() = Some(target.into().into());
+        self.opt_target_mut().target = Some(target.into().into());
         self
     }
 
@@ -927,7 +937,7 @@ pub trait OptTargetRefExt: OptTargetRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.target_field_mut() = Some(v.into());
+        self.opt_target_mut().target = Some(v.into());
         self
     }
 
@@ -951,14 +961,14 @@ pub trait OptTargetRefExt: OptTargetRef {
     where
         T: Into<AnyBase>,
     {
-        let c = match self.target_field_mut().take() {
+        let c = match self.opt_target_mut().target.take() {
             Some(mut c) => {
                 c.add(target.into());
                 c
             }
             None => vec![target.into()].into(),
         };
-        *self.target_field_mut() = Some(c);
+        self.opt_target_mut().target = Some(c);
         self
     }
 
@@ -980,7 +990,7 @@ pub trait OptTargetRefExt: OptTargetRef {
     /// # }
     /// ```
     fn take_target(&mut self) -> Option<OneOrMany<AnyBase>> {
-        self.target_field_mut().take()
+        self.opt_target_mut().target.take()
     }
 
     /// Delete a target from the current activity
@@ -1002,7 +1012,7 @@ pub trait OptTargetRefExt: OptTargetRef {
     /// # }
     /// ```
     fn delete_target(&mut self) -> &mut Self {
-        *self.target_field_mut() = None;
+        self.opt_target_mut().target = None;
         self
     }
 }
@@ -1011,7 +1021,7 @@ pub trait OptTargetRefExt: OptTargetRef {
 ///
 /// Documentation for the origin field can be found on the
 /// `Delete` struct
-pub trait OptOriginRefExt: OptOriginRef {
+pub trait AsOptOriginExt: AsOptOrigin {
     /// Fetch the origin for the current activity
     ///
     /// ```rust
@@ -1025,7 +1035,7 @@ pub trait OptOriginRefExt: OptOriginRef {
     /// }
     /// ```
     fn origin(&self) -> Option<&OneOrMany<AnyBase>> {
-        self.origin_field_ref().as_ref()
+        self.opt_origin_ref().origin.as_ref()
     }
 
     /// Set the origin for the current activity
@@ -1046,7 +1056,7 @@ pub trait OptOriginRefExt: OptOriginRef {
     where
         T: Into<AnyBase>,
     {
-        *self.origin_field_mut() = Some(origin.into().into());
+        self.opt_origin_mut().origin = Some(origin.into().into());
         self
     }
 
@@ -1073,7 +1083,7 @@ pub trait OptOriginRefExt: OptOriginRef {
         T: Into<AnyBase>,
     {
         let v: Vec<_> = items.into_iter().map(Into::into).collect();
-        *self.origin_field_mut() = Some(v.into());
+        self.opt_origin_mut().origin = Some(v.into());
         self
     }
 
@@ -1097,14 +1107,14 @@ pub trait OptOriginRefExt: OptOriginRef {
     where
         T: Into<AnyBase>,
     {
-        let c = match self.origin_field_mut().take() {
+        let c = match self.opt_origin_mut().origin.take() {
             Some(mut c) => {
                 c.add(origin.into());
                 c
             }
             None => vec![origin.into()].into(),
         };
-        *self.origin_field_mut() = Some(c);
+        self.opt_origin_mut().origin = Some(c);
         self
     }
 
@@ -1123,7 +1133,7 @@ pub trait OptOriginRefExt: OptOriginRef {
     /// # }
     /// ```
     fn take_origin(&mut self) -> Option<OneOrMany<AnyBase>> {
-        self.origin_field_mut().take()
+        self.opt_origin_mut().origin.take()
     }
 
     /// Delete a origin from the current activity
@@ -1142,7 +1152,7 @@ pub trait OptOriginRefExt: OptOriginRef {
     /// # }
     /// ```
     fn delete_origin(&mut self) -> &mut Self {
-        *self.origin_field_mut() = None;
+        self.opt_origin_mut().origin = None;
         self
     }
 }
@@ -1605,7 +1615,7 @@ pub trait QuestionExt: AsQuestion {
 /// The target property can be used in certain circumstances to indicate the context into which the
 /// object has been accepted.
 ///
-/// This is just an alias for `Object<AcceptType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<AcceptType>` because there's no fields inherent to
 /// Accept that aren't already present on an ActorAndObject.
 pub type Accept = ActorAndObject<AcceptType>;
 
@@ -1614,8 +1624,8 @@ pub type Accept = ActorAndObject<AcceptType>;
 /// If the target property is not explicitly specified, the target would need to be determined
 /// implicitly by context. The origin can be used to identify the context from which the object originated.
 ///
-/// This is just an alias for `Object<AddType>` because there's no fields inherent to
-/// Add that aren't already present on an ActorAndObjectOptOriginAndTarget.
+/// This is just an alias for `ActorAndObjectOptOriginAndTarget<AddType>` because there's no fields inherent to
+/// Add that aren't already present on an OptOrigin.
 pub type Add = ActorAndObjectOptOriginAndTarget<AddType>;
 
 /// Indicates that the actor is blocking the object.
@@ -1624,19 +1634,19 @@ pub type Add = ActorAndObjectOptOriginAndTarget<AddType>;
 /// one user to block activities or content of other users. The target and origin typically have no
 /// defined meaning.
 ///
-/// This is just an alias for `Object<BlockType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<BlockType>` because there's no fields inherent to
 /// Block that aren't already present on an ActorAndObject.
 pub type Block = ActorAndObject<BlockType>;
 
 /// Indicates that the actor has created the object.
 ///
-/// This is just an alias for `Object<CreateType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<CreateType>` because there's no fields inherent to
 /// Create that aren't already present on an ActorAndObject.
 pub type Create = ActorAndObject<CreateType>;
 
 /// Indicates that the actor dislikes the object.
 ///
-/// This is just an alias for `Object<DislikeType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<DislikeType>` because there's no fields inherent to
 /// Dislike that aren't already present on an ActorAndObject.
 pub type Dislike = ActorAndObject<DislikeType>;
 
@@ -1645,7 +1655,7 @@ pub type Dislike = ActorAndObject<DislikeType>;
 /// Flagging is defined in the sense common to many social platforms as reporting content as being
 /// inappropriate for any number of reasons.
 ///
-/// This is just an alias for `Object<FlagType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<FlagType>` because there's no fields inherent to
 /// Flag that aren't already present on an ActorAndObject.
 pub type Flag = ActorAndObject<FlagType>;
 
@@ -1655,7 +1665,7 @@ pub type Flag = ActorAndObject<FlagType>;
 /// interested in any activity performed by or on the object. The target and origin typically have
 /// no defined meaning.
 ///
-/// This is just an alias for `Object<FollowType>` because there's no fields inherent to Follow
+/// This is just an alias for `ActorAndObject<FollowType>` because there's no fields inherent to Follow
 /// that aren't already present on an ActorAndObject.
 pub type Follow = ActorAndObject<FollowType>;
 
@@ -1663,7 +1673,7 @@ pub type Follow = ActorAndObject<FollowType>;
 ///
 /// The target and origin typically have no defined meaning.
 ///
-/// This is just an alias for `Object<IgnoreType>` because there's no fields inherent to Ignore
+/// This is just an alias for `ActorAndObject<IgnoreType>` because there's no fields inherent to Ignore
 /// that aren't already present on an ActorAndObject.
 pub type Ignore = ActorAndObject<IgnoreType>;
 
@@ -1671,7 +1681,7 @@ pub type Ignore = ActorAndObject<IgnoreType>;
 ///
 /// The target and origin typically have no defined meaning
 ///
-/// This is just an alias for `Object<JoinType>` because there's no fields inherent to Join that
+/// This is just an alias for `ActorAndObject<JoinType>` because there's no fields inherent to Join that
 /// aren't already present on an ActorAndObject.
 pub type Join = ActorAndObject<JoinType>;
 
@@ -1679,7 +1689,7 @@ pub type Join = ActorAndObject<JoinType>;
 ///
 /// The target and origin typically have no meaning.
 ///
-/// This is just an alias for `Object<LeaveType>` because there's no fields inherent to Leave that
+/// This is just an alias for `ActorAndObject<LeaveType>` because there's no fields inherent to Leave that
 /// aren't already present on an ActorAndObject.
 pub type Leave = ActorAndObject<LeaveType>;
 
@@ -1687,19 +1697,19 @@ pub type Leave = ActorAndObject<LeaveType>;
 ///
 /// The target and origin typically have no defined meaning.
 ///
-/// This is just an alias for `Object<LikeType>` because there's no fields inherent to Like that
+/// This is just an alias for `ActorAndObject<LikeType>` because there's no fields inherent to Like that
 /// aren't already present on an ActorAndObject.
 pub type Like = ActorAndObject<LikeType>;
 
 /// Indicates that the actor has listened to the object.
 ///
-/// This is just an alias for `Object<ListenType>` because there's no fields inherent to Listen
+/// This is just an alias for `ActorAndObject<ListenType>` because there's no fields inherent to Listen
 /// that aren't already present on an ActorAndObject.
 pub type Listen = ActorAndObject<ListenType>;
 
 /// Indicates that the actor has read the object.
 ///
-/// This is just an alias for `Object<ReadType>` because there's no fields inherent to Read that
+/// This is just an alias for `ActorAndObject<ReadType>` because there's no fields inherent to Read that
 /// aren't already present on an ActorAndObject.
 pub type Read = ActorAndObject<ReadType>;
 
@@ -1707,19 +1717,19 @@ pub type Read = ActorAndObject<ReadType>;
 ///
 /// The target and origin typically have no defined meaning.
 ///
-/// This is just an alias for `Object<RejectType>` because there's no fields inherent to Reject
+/// This is just an alias for `ActorAndObject<RejectType>` because there's no fields inherent to Reject
 /// that aren't already present on an ActorAndObject.
 pub type Reject = ActorAndObject<RejectType>;
 
 /// A specialization of Accept indicating that the acceptance is tentative.
 ///
-/// This is just an alias for `Object<TentativeAcceptType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<TentativeAcceptType>` because there's no fields inherent to
 /// TentativeAccept that aren't already present on an ActorAndObject.
 pub type TentativeAccept = ActorAndObject<TentativeAcceptType>;
 
 /// A specialization of Reject in which the rejection is considered tentative.
 ///
-/// This is just an alias for `Object<TentativeRejectType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<TentativeRejectType>` because there's no fields inherent to
 /// TentativeReject that aren't already present on an ActorAndObject.
 pub type TentativeReject = ActorAndObject<TentativeRejectType>;
 
@@ -1731,7 +1741,7 @@ pub type TentativeReject = ActorAndObject<TentativeRejectType>;
 ///
 /// The target and origin typically have no defined meaning.
 ///
-/// This is just an alias for `Object<UndoType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<UndoType>` because there's no fields inherent to
 /// Undo that aren't already present on an ActorAndObject.
 pub type Undo = ActorAndObject<UndoType>;
 
@@ -1742,13 +1752,13 @@ pub type Undo = ActorAndObject<UndoType>;
 ///
 /// The target and origin typically have no defined meaning.
 ///
-/// This is just an alias for `Object<UpdateType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<UpdateType>` because there's no fields inherent to
 /// Update that aren't already present on an ActorAndObject.
 pub type Update = ActorAndObject<UpdateType>;
 
 /// Indicates that the actor has viewed the object.
 ///
-/// This is just an alias for `Object<ViewType>` because there's no fields inherent to
+/// This is just an alias for `ActorAndObject<ViewType>` because there's no fields inherent to
 /// View that aren't already present on an ActorAndObject.
 pub type View = ActorAndObject<ViewType>;
 
@@ -1756,338 +1766,54 @@ pub type View = ActorAndObject<ViewType>;
 ///
 /// The origin typically has no defined meaning.
 ///
-/// This is just an alias for `Object<AnnounceType>` because there's no fields inherent to
-/// Announce that aren't already present on an ActorAndObjectOptTarget.
+/// This is just an alias for `ActorAndObjectOptTarget<AnnounceType>` because there's no fields inherent to
+/// Announce that aren't already present on an OptTarget.
 pub type Announce = ActorAndObjectOptTarget<AnnounceType>;
 
 /// Indicates that the actor is offering the object.
 ///
 /// If specified, the target indicates the entity to which the object is being offered.
 ///
-/// This is just an alias for `Object<OfferType>` because there's no fields inherent to
-/// Offer that aren't already present on an ActorAndObjectOptTarget.
+/// This is just an alias for `ActorAndObjectOptTarget<OfferType>` because there's no fields inherent to
+/// Offer that aren't already present on an OptTarget.
 pub type Offer = ActorAndObjectOptTarget<OfferType>;
 
 /// Indicates that the actor has moved object from origin to target.
 ///
 /// If the origin or target are not specified, either can be determined by context.
 ///
-/// This is just an alias for `Object<MoveType>` because there's no fields inherent to
-/// Move that aren't already present on an ActorAndObjectOptOriginAndTarget.
-pub type Move = ActorAndObjectOptOriginAndTarget<MoveType>;
+/// This is just an alias for `ActorAndObject<MoveType>` because there's no fields inherent to
+/// Move that aren't already present on an OptOrigin.
+pub type Move = ActorAndObjectOptOrigin<MoveType>;
 
 /// Indicates that the actor is removing the object.
 ///
 /// If specified, the origin indicates the context from which the object is being removed.
 ///
-/// This is just an alias for `Object<RemoveType>` because there's no fields inherent to
-/// Remove that aren't already present on an ActorAndObjectOptOriginAndTarget.
-pub type Remove = ActorAndObjectOptOriginAndTarget<RemoveType>;
-
-/// Activity objects are specializations of the base Object type that provide information about
-/// actions that have either already occurred, are in the process of occurring, or may occur in the
-/// future.
-#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Activity<Kind> {
-    /// Describes the result of the activity.
-    ///
-    /// For instance, if a particular action results in the creation of a new resource, the result
-    /// property can be used to describe that new resource.
-    ///
-    /// - Range: Object | Link
-    /// - Funcitonal: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    result: Option<OneOrMany<AnyBase>>,
-
-    /// Identifies one or more objects used (or to be used) in the completion of an Activity.
-    ///
-    /// - Range: Object | Link
-    /// - Funcitonal: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    instrument: Option<OneOrMany<AnyBase>>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Object<Kind>,
-}
-
-/// Activity with actor and object properties
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ActorAndObject<Kind> {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// When used within an Activity, describes the direct object of the activity.
-    ///
-    /// For instance, in the activity "John added a movie to his wishlist", the object of the
-    /// activity is the movie added.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    object: OneOrMany<AnyBase>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<Kind>,
-}
+/// This is just an alias for `ActorAndObject<RemoveType>` because there's no fields inherent to
+/// Remove that aren't already present on an OptOrigin.
+pub type Remove = ActorAndObjectOptOrigin<RemoveType>;
 
 /// An IntransitiveActivity that indicates that the actor has arrived at the location.
 ///
 /// The origin can be used to identify the context from which the actor originated. The target
 /// typically has no defined meaning.
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Arrive {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// Describes an indirect object of the activity from which the activity is directed.
-    ///
-    /// The precise meaning of the origin is the object of the English preposition "from". For
-    /// instance, in the activity "John moved an item to List B from List A", the origin of the
-    /// activity is "List A".
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    origin: OneOrMany<AnyBase>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<ArriveType>,
-}
+pub type Arrive = ActorAndOrigin<ArriveType>;
 
 /// A specialization of Offer in which the actor is extending an invitation for the object to the
 /// target.
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Invite {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// When used within an Activity, describes the direct object of the activity.
-    ///
-    /// For instance, in the activity "John added a movie to his wishlist", the object of the
-    /// activity is the movie added.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    object: OneOrMany<AnyBase>,
-
-    /// Describes the indirect object, or target, of the activity.
-    ///
-    /// The precise meaning of the target is largely dependent on the type of action being
-    /// described but will often be the object of the English preposition "to". For instance, in
-    /// the activity "John added a movie to his wishlist", the target of the activity is John's
-    /// wishlist. An activity can have more than one target
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    target: OneOrMany<AnyBase>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<InviteType>,
-}
+pub type Invite = Target<ActorAndObject<InviteType>>;
 
 /// Indicates that the actor has deleted the object.
 ///
 /// If specified, the origin indicates the context from which the object was deleted.
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Delete {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// When used within an Activity, describes the direct object of the activity.
-    ///
-    /// For instance, in the activity "John added a movie to his wishlist", the object of the
-    /// activity is the movie added.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    object: OneOrMany<AnyBase>,
-
-    /// Describes an indirect object of the activity from which the activity is directed.
-    ///
-    /// The precise meaning of the origin is the object of the English preposition "from". For
-    /// instance, in the activity "John moved an item to List B from List A", the origin of the
-    /// activity is "List A".
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    origin: Option<OneOrMany<AnyBase>>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<DeleteType>,
-}
-
-/// Activity with actor, object, and optional origin and target properties
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ActorAndObjectOptOriginAndTarget<Kind> {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// When used within an Activity, describes the direct object of the activity.
-    ///
-    /// For instance, in the activity "John added a movie to his wishlist", the object of the
-    /// activity is the movie added.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    object: OneOrMany<AnyBase>,
-
-    /// Describes an indirect object of the activity from which the activity is directed.
-    ///
-    /// The precise meaning of the origin is the object of the English preposition "from". For
-    /// instance, in the activity "John moved an item to List B from List A", the origin of the
-    /// activity is "List A".
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    origin: Option<OneOrMany<AnyBase>>,
-
-    /// Describes the indirect object, or target, of the activity.
-    ///
-    /// The precise meaning of the target is largely dependent on the type of action being
-    /// described but will often be the object of the English preposition "to". For instance, in
-    /// the activity "John added a movie to his wishlist", the target of the activity is John's
-    /// wishlist. An activity can have more than one target
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    target: Option<OneOrMany<AnyBase>>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<Kind>,
-}
-
-/// Activity with actor, object, and optional target properties
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ActorAndObjectOptTarget<Kind> {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// When used within an Activity, describes the direct object of the activity.
-    ///
-    /// For instance, in the activity "John added a movie to his wishlist", the object of the
-    /// activity is the movie added.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    object: OneOrMany<AnyBase>,
-
-    /// Describes the indirect object, or target, of the activity.
-    ///
-    /// The precise meaning of the target is largely dependent on the type of action being
-    /// described but will often be the object of the English preposition "to". For instance, in
-    /// the activity "John added a movie to his wishlist", the target of the activity is John's
-    /// wishlist. An activity can have more than one target
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    target: Option<OneOrMany<AnyBase>>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<Kind>,
-}
+pub type Delete = ActorAndObjectOptOrigin<DeleteType>;
 
 /// Indicates that the actor is traveling to target from origin.
 ///
 /// Travel is an IntransitiveObject whose actor specifies the direct object. If the target or
 /// origin are not specified, either can be determined by context.
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Travel {
-    /// Describes one or more entities that either performed or are expected to perform the
-    /// activity.
-    ///
-    /// Any single activity can have multiple actors. The actor MAY be specified using an indirect
-    /// Link.
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    actor: OneOrMany<AnyBase>,
-
-    /// Describes an indirect object of the activity from which the activity is directed.
-    ///
-    /// The precise meaning of the origin is the object of the English preposition "from". For
-    /// instance, in the activity "John moved an item to List B from List A", the origin of the
-    /// activity is "List A".
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    origin: Option<OneOrMany<AnyBase>>,
-
-    /// Describes the indirect object, or target, of the activity.
-    ///
-    /// The precise meaning of the target is largely dependent on the type of action being
-    /// described but will often be the object of the English preposition "to". For instance, in
-    /// the activity "John added a movie to his wishlist", the target of the activity is John's
-    /// wishlist. An activity can have more than one target
-    ///
-    /// - Range: Object | Link
-    /// - Functional: false
-    #[serde(skip_serializing_if = "Option::is_none")]
-    target: Option<OneOrMany<AnyBase>>,
-
-    /// base fields and unparsed json ends up here
-    #[serde(flatten)]
-    inner: Activity<TravelType>,
-}
+pub type Travel = OptOrigin<OptTarget<ActivityActor<Activity<TravelType>>>>;
 
 /// Represents a question being asked.
 ///
@@ -2132,6 +1858,151 @@ pub struct Question {
     inner: Activity<QuestionType>,
 }
 
+/// Activity with actor and object properties
+pub type ActorAndObject<Kind> = ActivityActor<ActivityObject<Activity<Kind>>>;
+
+/// Activity with actor and origin properties
+pub type ActorAndOrigin<Kind> = Origin<ActivityActor<Activity<Kind>>>;
+
+/// Activity with actor and object properties, and optional origin and target properties
+pub type ActorAndObjectOptOriginAndTarget<Kind> = OptOrigin<OptTarget<ActorAndObject<Kind>>>;
+
+/// Activity with actor and object properties, and and optional origin property
+pub type ActorAndObjectOptOrigin<Kind> = OptOrigin<ActorAndObject<Kind>>;
+
+/// Activity with actor and object properties, and and optional target property
+pub type ActorAndObjectOptTarget<Kind> = OptTarget<ActorAndObject<Kind>>;
+
+/// Activity objects are specializations of the base Object type that provide information about
+/// actions that have either already occurred, are in the process of occurring, or may occur in the
+/// future.
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Activity<Kind> {
+    /// Describes the result of the activity.
+    ///
+    /// For instance, if a particular action results in the creation of a new resource, the result
+    /// property can be used to describe that new resource.
+    ///
+    /// - Range: Object | Link
+    /// - Funcitonal: false
+    #[serde(skip_serializing_if = "Option::is_none")]
+    result: Option<OneOrMany<AnyBase>>,
+
+    /// Identifies one or more objects used (or to be used) in the completion of an Activity.
+    ///
+    /// - Range: Object | Link
+    /// - Funcitonal: false
+    #[serde(skip_serializing_if = "Option::is_none")]
+    instrument: Option<OneOrMany<AnyBase>>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Object<Kind>,
+}
+
+/// Activity with an actor property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActivityActor<Inner> {
+    actor: OneOrMany<AnyBase>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
+/// Activity with an object property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActivityObject<Inner> {
+    object: OneOrMany<AnyBase>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
+/// Activity with an origin property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Origin<Inner> {
+    /// Describes an indirect object of the activity from which the activity is directed.
+    ///
+    /// The precise meaning of the origin is the object of the English preposition "from". For
+    /// instance, in the activity "John moved an item to List B from List A", the origin of the
+    /// activity is "List A".
+    ///
+    /// - Range: Object | Link
+    /// - Functional: false
+    origin: OneOrMany<AnyBase>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
+/// Activity with an optional origin property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OptOrigin<Inner> {
+    /// Describes an indirect object of the activity from which the activity is directed.
+    ///
+    /// The precise meaning of the origin is the object of the English preposition "from". For
+    /// instance, in the activity "John moved an item to List B from List A", the origin of the
+    /// activity is "List A".
+    ///
+    /// - Range: Object | Link
+    /// - Functional: false
+    #[serde(skip_serializing_if = "Option::is_none")]
+    origin: Option<OneOrMany<AnyBase>>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
+/// Activity with a target property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Target<Inner> {
+    /// Describes the indirect object, or target, of the activity.
+    ///
+    /// The precise meaning of the target is largely dependent on the type of action being
+    /// described but will often be the object of the English preposition "to". For instance, in
+    /// the activity "John added a movie to his wishlist", the target of the activity is John's
+    /// wishlist. An activity can have more than one target
+    ///
+    /// - Range: Object | Link
+    /// - Functional: false
+    target: OneOrMany<AnyBase>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
+/// Activity with an optional target property
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OptTarget<Inner> {
+    /// Describes the indirect object, or target, of the activity.
+    ///
+    /// The precise meaning of the target is largely dependent on the type of action being
+    /// described but will often be the object of the English preposition "to". For instance, in
+    /// the activity "John added a movie to his wishlist", the target of the activity is John's
+    /// wishlist. An activity can have more than one target
+    ///
+    /// - Range: Object | Link
+    /// - Functional: false
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<OneOrMany<AnyBase>>,
+
+    /// base fields and unparsed json ends up here
+    #[serde(flatten)]
+    inner: Inner,
+}
+
 impl<Kind> Activity<Kind> {
     /// Create a new Activity
     ///
@@ -2201,6 +2072,226 @@ impl<Kind> Activity<Kind> {
     }
 }
 
+impl<Inner> ActivityActor<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let actor = inner.remove("actor")?;
+
+        Ok(ActivityActor { actor, inner })
+    }
+
+    fn retracting(self) -> Result<Inner, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let ActivityActor { actor, mut inner } = self;
+
+        inner.insert("actor", actor)?;
+
+        Ok(inner)
+    }
+}
+
+impl<Inner> ActivityObject<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let object = inner.remove("object")?;
+
+        Ok(ActivityObject { object, inner })
+    }
+
+    fn retracting(self) -> Result<Inner, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let ActivityObject { object, mut inner } = self;
+
+        inner.insert("object", object)?;
+
+        Ok(inner)
+    }
+}
+
+impl Arrive {
+    pub fn new<T, U>(actor: T, origin: U) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+        U: Into<OneOrMany<AnyBase>>,
+    {
+        Origin {
+            origin: origin.into(),
+            inner: ActivityActor {
+                actor: actor.into(),
+                inner: Activity::new(),
+            },
+        }
+    }
+
+    /// Deconstruct the Arrive into its parts
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Arrive;
+    ///
+    /// let activity = Arrive::new(vec![], vec![]);
+    ///
+    /// let (actor, origin, activity) = activity.into_parts();
+    /// ```
+    pub fn into_parts(self) -> (OneOrMany<AnyBase>, OneOrMany<AnyBase>, Activity<ArriveType>) {
+        (self.inner.actor, self.origin, self.inner.inner)
+    }
+}
+
+impl Invite {
+    pub fn new<T, U, V>(actor: T, object: U, target: V) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+        U: Into<OneOrMany<AnyBase>>,
+        V: Into<OneOrMany<AnyBase>>,
+    {
+        Target {
+            target: target.into(),
+            inner: ActivityActor {
+                actor: actor.into(),
+                inner: ActivityObject {
+                    object: object.into(),
+                    inner: Activity::new(),
+                },
+            },
+        }
+    }
+
+    /// Deconstruct the Invite into its parts
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Invite;
+    ///
+    /// let activity = Invite::new(vec![], vec![], vec![]);
+    ///
+    /// let (actor, object, target, activity) = activity.into_parts();
+    /// ```
+    pub fn into_parts(
+        self,
+    ) -> (
+        OneOrMany<AnyBase>,
+        OneOrMany<AnyBase>,
+        OneOrMany<AnyBase>,
+        Activity<InviteType>,
+    ) {
+        (
+            self.inner.actor,
+            self.inner.inner.object,
+            self.target,
+            self.inner.inner.inner,
+        )
+    }
+}
+
+impl Delete {
+    /// Create a new Delete Activity
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Delete;
+    ///
+    /// let activity = Delete::new(vec![], vec![]);
+    /// ```
+    pub fn new<T, U>(actor: T, object: U) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+        U: Into<OneOrMany<AnyBase>>,
+    {
+        OptOrigin {
+            origin: None,
+            inner: ActivityActor {
+                actor: actor.into(),
+                inner: ActivityObject {
+                    object: object.into(),
+                    inner: Activity::new(),
+                },
+            },
+        }
+    }
+
+    /// Deconstruct the Delete into its parts
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Delete;
+    ///
+    /// let activity = Delete::new(vec![], vec![]);
+    ///
+    /// let (actor, object, origin, activity) = activity.into_parts();
+    /// ```
+    pub fn into_parts(
+        self,
+    ) -> (
+        OneOrMany<AnyBase>,
+        OneOrMany<AnyBase>,
+        Option<OneOrMany<AnyBase>>,
+        Activity<DeleteType>,
+    ) {
+        (
+            self.inner.actor,
+            self.inner.inner.object,
+            self.origin,
+            self.inner.inner.inner,
+        )
+    }
+}
+
+impl Travel {
+    /// Create a new Travel Activity
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Travel;
+    ///
+    /// let activity = Travel::new(vec![]);
+    /// ```
+    pub fn new<T>(actor: T) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+    {
+        OptOrigin {
+            origin: None,
+            inner: OptTarget {
+                target: None,
+                inner: ActivityActor {
+                    actor: actor.into(),
+                    inner: Activity::new(),
+                },
+            },
+        }
+    }
+
+    #[allow(clippy::type_complexity)]
+    /// Deconstruct the Travel into its parts
+    ///
+    /// ```rust
+    /// use activitystreams::activity::Travel;
+    ///
+    /// let activity = Travel::new(vec![]);
+    ///
+    /// let (actor, origin, target, activity) = activity.into_parts();
+    /// ```
+    pub fn into_parts(
+        self,
+    ) -> (
+        OneOrMany<AnyBase>,
+        Option<OneOrMany<AnyBase>>,
+        Option<OneOrMany<AnyBase>>,
+        Activity<TravelType>,
+    ) {
+        (
+            self.inner.inner.actor,
+            self.origin,
+            self.inner.target,
+            self.inner.inner.inner,
+        )
+    }
+}
+
 impl<Kind> ActorAndObject<Kind> {
     /// Create a new ActorAndObject Activity
     ///
@@ -2215,10 +2306,12 @@ impl<Kind> ActorAndObject<Kind> {
         U: Into<OneOrMany<AnyBase>>,
         Kind: Default,
     {
-        ActorAndObject {
+        ActivityActor {
             actor: actor.into(),
-            object: object.into(),
-            inner: Activity::new(),
+            inner: ActivityObject {
+                object: object.into(),
+                inner: Activity::new(),
+            },
         }
     }
 
@@ -2243,10 +2336,12 @@ impl<Kind> ActorAndObject<Kind> {
         T: Into<OneOrMany<AnyBase>>,
         U: Into<OneOrMany<AnyBase>>,
     {
-        ActorAndObject {
+        ActivityActor {
             actor: actor.into(),
-            object: object.into(),
-            inner: Activity::new_none_type(),
+            inner: ActivityObject {
+                object: object.into(),
+                inner: Activity::new_none_type(),
+            },
         }
     }
 
@@ -2260,248 +2355,17 @@ impl<Kind> ActorAndObject<Kind> {
     /// let (actor, object, activity) = activity.into_parts();
     /// ```
     pub fn into_parts(self) -> (OneOrMany<AnyBase>, OneOrMany<AnyBase>, Activity<Kind>) {
-        (self.actor, self.object, self.inner)
-    }
-
-    fn extending(object: Object<Kind>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let object = inner.remove("object")?;
-
-        Ok(ActorAndObject {
-            actor,
-            object,
-            inner,
-        })
-    }
-
-    fn retracting(self) -> Result<Object<Kind>, serde_json::Error> {
-        let ActorAndObject {
-            actor,
-            object,
-            mut inner,
-        } = self;
-
-        inner.insert("actor", actor)?.insert("object", object)?;
-
-        inner.retracting()
+        (self.actor, self.inner.object, self.inner.inner)
     }
 }
 
-impl Arrive {
-    /// Create a new Arrive Activity
+impl<Kind> ActorAndObjectOptTarget<Kind> {
+    /// Create a new ActorAndObjectOptTarget Activity
     ///
     /// ```rust
-    /// use activitystreams::activity::Arrive;
+    /// use activitystreams::activity::ActorAndObjectOptTarget;
     ///
-    /// let activity = Arrive::new(vec![], vec![]);
-    /// ```
-    pub fn new<T, U>(actor: T, origin: U) -> Self
-    where
-        T: Into<OneOrMany<AnyBase>>,
-        U: Into<OneOrMany<AnyBase>>,
-    {
-        Arrive {
-            actor: actor.into(),
-            origin: origin.into(),
-            inner: Activity::new(),
-        }
-    }
-
-    /// Deconstruct the Arrive into its parts
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Arrive;
-    ///
-    /// let activity = Arrive::new(vec![], vec![]);
-    ///
-    /// let (actor, origin, activity) = activity.into_parts();
-    /// ```
-    pub fn into_parts(self) -> (OneOrMany<AnyBase>, OneOrMany<AnyBase>, Activity<ArriveType>) {
-        (self.actor, self.origin, self.inner)
-    }
-
-    fn extending(object: Object<ArriveType>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let origin = inner.remove("origin")?;
-
-        Ok(Arrive {
-            actor,
-            origin,
-            inner,
-        })
-    }
-
-    fn retracting(self) -> Result<Object<ArriveType>, serde_json::Error> {
-        let Arrive {
-            actor,
-            origin,
-            mut inner,
-        } = self;
-
-        inner.insert("actor", actor)?.insert("origin", origin)?;
-
-        inner.retracting()
-    }
-}
-
-impl Invite {
-    /// Create a new Invite Activity
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Invite;
-    ///
-    /// let activity = Invite::new(vec![], vec![], vec![]);
-    /// ```
-    pub fn new<T, U, V>(actor: T, object: U, target: V) -> Self
-    where
-        T: Into<OneOrMany<AnyBase>>,
-        U: Into<OneOrMany<AnyBase>>,
-        V: Into<OneOrMany<AnyBase>>,
-    {
-        Invite {
-            actor: actor.into(),
-            object: object.into(),
-            target: target.into(),
-            inner: Activity::new(),
-        }
-    }
-
-    /// Deconstruct the Invite into its parts
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Invite;
-    ///
-    /// let activity = Invite::new(vec![], vec![], vec![]);
-    ///
-    /// let (actor, object, target, activity) = activity.into_parts();
-    /// ```
-    pub fn into_parts(
-        self,
-    ) -> (
-        OneOrMany<AnyBase>,
-        OneOrMany<AnyBase>,
-        OneOrMany<AnyBase>,
-        Activity<InviteType>,
-    ) {
-        (self.actor, self.object, self.target, self.inner)
-    }
-
-    fn extending(object: Object<InviteType>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let object = inner.remove("object")?;
-        let target = inner.remove("target")?;
-
-        Ok(Invite {
-            actor,
-            object,
-            target,
-            inner,
-        })
-    }
-
-    fn retracting(self) -> Result<Object<InviteType>, serde_json::Error> {
-        let Invite {
-            actor,
-            object,
-            target,
-            mut inner,
-        } = self;
-
-        inner
-            .insert("actor", actor)?
-            .insert("object", object)?
-            .insert("target", target)?;
-
-        inner.retracting()
-    }
-}
-
-impl Delete {
-    /// Create a new Delete Activity
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Delete;
-    ///
-    /// let activity = Delete::new(vec![], vec![]);
-    /// ```
-    pub fn new<T, U>(actor: T, object: U) -> Self
-    where
-        T: Into<OneOrMany<AnyBase>>,
-        U: Into<OneOrMany<AnyBase>>,
-    {
-        Delete {
-            actor: actor.into(),
-            object: object.into(),
-            origin: None,
-            inner: Activity::new(),
-        }
-    }
-
-    /// Deconstruct the Delete into its parts
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Delete;
-    ///
-    /// let activity = Delete::new(vec![], vec![]);
-    ///
-    /// let (actor, object, origin, activity) = activity.into_parts();
-    /// ```
-    pub fn into_parts(
-        self,
-    ) -> (
-        OneOrMany<AnyBase>,
-        OneOrMany<AnyBase>,
-        Option<OneOrMany<AnyBase>>,
-        Activity<DeleteType>,
-    ) {
-        (self.actor, self.object, self.origin, self.inner)
-    }
-
-    fn extending(object: Object<DeleteType>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let object = inner.remove("object")?;
-        let origin = inner.remove("origin")?;
-
-        Ok(Delete {
-            actor,
-            object,
-            origin,
-            inner,
-        })
-    }
-
-    fn retracting(self) -> Result<Object<DeleteType>, serde_json::Error> {
-        let Delete {
-            actor,
-            object,
-            origin,
-            mut inner,
-        } = self;
-
-        inner
-            .insert("actor", actor)?
-            .insert("object", object)?
-            .insert("origin", origin)?;
-
-        inner.retracting()
-    }
-}
-
-impl<Kind> ActorAndObjectOptOriginAndTarget<Kind> {
-    /// Create a new ActorAndObjectOptOriginAndTarget Activity
-    ///
-    /// ```rust
-    /// use activitystreams::activity::ActorAndObjectOptOriginAndTarget;
-    ///
-    /// let activity = ActorAndObjectOptOriginAndTarget::<String>::new(
+    /// let activity = ActorAndObjectOptTarget::<String>::new(
     ///     vec![],
     ///     vec![]
     /// );
@@ -2512,16 +2376,108 @@ impl<Kind> ActorAndObjectOptOriginAndTarget<Kind> {
         U: Into<OneOrMany<AnyBase>>,
         Kind: Default,
     {
-        ActorAndObjectOptOriginAndTarget {
-            actor: actor.into(),
-            object: object.into(),
-            origin: None,
+        OptTarget {
             target: None,
-            inner: Activity::new(),
+            inner: ActivityActor {
+                actor: actor.into(),
+                inner: ActivityObject {
+                    object: object.into(),
+                    inner: Activity::new(),
+                },
+            },
         }
     }
 
-    /// Create a new ActorAndObjectOptOriginAndTarget with `None` for it's `kind` property
+    /// Create a new ActorAndObject with `None` for it's `kind` property
+    ///
+    /// This means that no `type` field will be present in serialized JSON
+    ///
+    /// ```rust
+    /// # fn main() -> Result<(), anyhow::Error> {
+    /// use activitystreams::activity::ActorAndObjectOptTarget;
+    ///
+    /// let activity = ActorAndObjectOptTarget::<()>::new_none_type(vec![], vec![]);
+    ///
+    /// let s = serde_json::to_string(&activity)?;
+    ///
+    /// assert_eq!(s, r#"{"actor":[],"object":[]}"#);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new_none_type<T, U>(actor: T, object: U) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+        U: Into<OneOrMany<AnyBase>>,
+    {
+        OptTarget {
+            target: None,
+            inner: ActivityActor {
+                actor: actor.into(),
+                inner: ActivityObject {
+                    object: object.into(),
+                    inner: Activity::new_none_type(),
+                },
+            },
+        }
+    }
+
+    #[allow(clippy::type_complexity)]
+    /// Deconstruct the ActorAndObjectOptTarget into its parts
+    ///
+    /// ```rust
+    /// use activitystreams::activity::ActorAndObjectOptTarget;
+    ///
+    /// let activity = ActorAndObjectOptTarget::<String>::new(vec![], vec![]);
+    ///
+    /// let (actor, object, target, activity) = activity.into_parts();
+    /// ```
+    pub fn into_parts(
+        self,
+    ) -> (
+        OneOrMany<AnyBase>,
+        OneOrMany<AnyBase>,
+        Option<OneOrMany<AnyBase>>,
+        Activity<Kind>,
+    ) {
+        (
+            self.inner.actor,
+            self.inner.inner.object,
+            self.target,
+            self.inner.inner.inner,
+        )
+    }
+}
+
+impl<Kind> ActorAndObjectOptOriginAndTarget<Kind> {
+    /// Create a new ActorAndObject Activity
+    ///
+    /// ```rust
+    /// use activitystreams::activity::ActorAndObjectOptOriginAndTarget;
+    ///
+    /// let activity = ActorAndObjectOptOriginAndTarget::<String>::new(vec![], vec![]);
+    /// ```
+    pub fn new<T, U>(actor: T, object: U) -> Self
+    where
+        T: Into<OneOrMany<AnyBase>>,
+        U: Into<OneOrMany<AnyBase>>,
+        Kind: Default,
+    {
+        OptOrigin {
+            origin: None,
+            inner: OptTarget {
+                target: None,
+                inner: ActivityActor {
+                    actor: actor.into(),
+                    inner: ActivityObject {
+                        object: object.into(),
+                        inner: Activity::new(),
+                    },
+                },
+            },
+        }
+    }
+
+    /// Create a new ActorAndObject with `None` for it's `kind` property
     ///
     /// This means that no `type` field will be present in serialized JSON
     ///
@@ -2542,12 +2498,18 @@ impl<Kind> ActorAndObjectOptOriginAndTarget<Kind> {
         T: Into<OneOrMany<AnyBase>>,
         U: Into<OneOrMany<AnyBase>>,
     {
-        ActorAndObjectOptOriginAndTarget {
-            actor: actor.into(),
-            object: object.into(),
+        OptOrigin {
             origin: None,
-            target: None,
-            inner: Activity::new_none_type(),
+            inner: OptTarget {
+                target: None,
+                inner: ActivityActor {
+                    actor: actor.into(),
+                    inner: ActivityObject {
+                        object: object.into(),
+                        inner: Activity::new_none_type(),
+                    },
+                },
+            },
         }
     }
 
@@ -2571,226 +2533,100 @@ impl<Kind> ActorAndObjectOptOriginAndTarget<Kind> {
         Activity<Kind>,
     ) {
         (
-            self.actor,
-            self.object,
+            self.inner.inner.actor,
+            self.inner.inner.inner.object,
             self.origin,
-            self.target,
-            self.inner,
+            self.inner.target,
+            self.inner.inner.inner.inner,
         )
     }
+}
 
-    fn extending(object: Object<Kind>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let object = inner.remove("object")?;
+impl<Inner> Origin<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
         let origin = inner.remove("origin")?;
-        let target = inner.remove("target")?;
 
-        Ok(ActorAndObjectOptOriginAndTarget {
-            actor,
-            object,
-            origin,
-            target,
-            inner,
-        })
+        Ok(Origin { origin, inner })
     }
 
-    fn retracting(self) -> Result<Object<Kind>, serde_json::Error> {
-        let ActorAndObjectOptOriginAndTarget {
-            actor,
-            object,
-            origin,
-            target,
-            mut inner,
-        } = self;
+    fn retracting(self) -> Result<Inner, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let Origin { origin, mut inner } = self;
 
-        inner
-            .insert("actor", actor)?
-            .insert("object", object)?
-            .insert("origin", origin)?
-            .insert("target", target)?;
+        inner.insert("origin", origin)?;
 
-        inner.retracting()
+        Ok(inner)
     }
 }
 
-impl<Kind> ActorAndObjectOptTarget<Kind> {
-    /// Create a new ActorAndObjectOptTarget Activity
-    ///
-    /// ```rust
-    /// use activitystreams::activity::ActorAndObjectOptTarget;
-    ///
-    /// let activity = ActorAndObjectOptTarget::<String>::new(
-    ///     vec![],
-    ///     vec![]
-    /// );
-    /// ```
-    pub fn new<T, U>(actor: T, object: U) -> Self
+impl<Inner> OptOrigin<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
     where
-        T: Into<OneOrMany<AnyBase>>,
-        U: Into<OneOrMany<AnyBase>>,
-        Kind: Default,
+        Inner: UnparsedMut,
     {
-        ActorAndObjectOptTarget {
-            actor: actor.into(),
-            object: object.into(),
-            target: None,
-            inner: Activity::new(),
-        }
+        let origin = inner.remove("origin")?;
+
+        Ok(OptOrigin { origin, inner })
     }
 
-    /// Create a new ActorAndObjectOptTarget with `None` for it's `kind` property
-    ///
-    /// This means that no `type` field will be present in serialized JSON
-    ///
-    /// ```rust
-    /// # fn main() -> Result<(), anyhow::Error> {
-    /// use activitystreams::activity::ActorAndObjectOptTarget;
-    ///
-    /// let activity = ActorAndObjectOptTarget::<()>::new_none_type(vec![], vec![]);
-    ///
-    /// let s = serde_json::to_string(&activity)?;
-    ///
-    /// assert_eq!(s, r#"{"actor":[],"object":[]}"#);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new_none_type<T, U>(actor: T, object: U) -> Self
+    fn retracting(self) -> Result<Inner, serde_json::Error>
     where
-        T: Into<OneOrMany<AnyBase>>,
-        U: Into<OneOrMany<AnyBase>>,
+        Inner: UnparsedMut,
     {
-        ActorAndObjectOptTarget {
-            actor: actor.into(),
-            object: object.into(),
-            target: None,
-            inner: Activity::new_none_type(),
-        }
-    }
+        let OptOrigin { origin, mut inner } = self;
 
-    /// Deconstruct the ActorAndObjectOptTarget into its parts
-    ///
-    /// ```rust
-    /// use activitystreams::activity::ActorAndObjectOptTarget;
-    ///
-    /// let activity = ActorAndObjectOptTarget::<String>::new(vec![], vec![]);
-    ///
-    /// let (actor, object, target, activity) = activity.into_parts();
-    /// ```
-    pub fn into_parts(
-        self,
-    ) -> (
-        OneOrMany<AnyBase>,
-        OneOrMany<AnyBase>,
-        Option<OneOrMany<AnyBase>>,
-        Activity<Kind>,
-    ) {
-        (self.actor, self.object, self.target, self.inner)
-    }
+        inner.insert("origin", origin)?;
 
-    fn extending(object: Object<Kind>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let object = inner.remove("object")?;
-        let target = inner.remove("target")?;
-
-        Ok(ActorAndObjectOptTarget {
-            actor,
-            object,
-            target,
-            inner,
-        })
-    }
-
-    fn retracting(self) -> Result<Object<Kind>, serde_json::Error> {
-        let ActorAndObjectOptTarget {
-            actor,
-            object,
-            target,
-            mut inner,
-        } = self;
-
-        inner
-            .insert("actor", actor)?
-            .insert("object", object)?
-            .insert("target", target)?;
-
-        inner.retracting()
+        Ok(inner)
     }
 }
 
-impl Travel {
-    /// Create a new Travel Activity
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Travel;
-    ///
-    /// let activity = Travel::new(vec![]);
-    /// ```
-    pub fn new<T>(actor: T) -> Self
+impl<Inner> Target<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
     where
-        T: Into<OneOrMany<AnyBase>>,
+        Inner: UnparsedMut,
     {
-        Travel {
-            actor: actor.into(),
-            origin: None,
-            target: None,
-            inner: Activity::new(),
-        }
-    }
-
-    #[allow(clippy::type_complexity)]
-    /// Deconstruct the Travel into its parts
-    ///
-    /// ```rust
-    /// use activitystreams::activity::Travel;
-    ///
-    /// let activity = Travel::new(vec![]);
-    ///
-    /// let (actor, origin, target, activity) = activity.into_parts();
-    /// ```
-    pub fn into_parts(
-        self,
-    ) -> (
-        OneOrMany<AnyBase>,
-        Option<OneOrMany<AnyBase>>,
-        Option<OneOrMany<AnyBase>>,
-        Activity<TravelType>,
-    ) {
-        (self.actor, self.origin, self.target, self.inner)
-    }
-
-    fn extending(object: Object<TravelType>) -> Result<Self, serde_json::Error> {
-        let mut inner = Activity::extending(object)?;
-
-        let actor = inner.remove("actor")?;
-        let origin = inner.remove("origin")?;
         let target = inner.remove("target")?;
 
-        Ok(Travel {
-            actor,
-            origin,
-            target,
-            inner,
-        })
+        Ok(Target { target, inner })
     }
 
-    fn retracting(self) -> Result<Object<TravelType>, serde_json::Error> {
-        let Travel {
-            actor,
-            origin,
-            target,
-            mut inner,
-        } = self;
+    fn retracting(self) -> Result<Inner, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let Target { target, mut inner } = self;
 
-        inner
-            .insert("actor", actor)?
-            .insert("origin", origin)?
-            .insert("target", target)?;
+        inner.insert("target", target)?;
 
-        inner.retracting()
+        Ok(inner)
+    }
+}
+
+impl<Inner> OptTarget<Inner> {
+    fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let target = inner.remove("target")?;
+
+        Ok(OptTarget { target, inner })
+    }
+
+    fn retracting(self) -> Result<Inner, serde_json::Error>
+    where
+        Inner: UnparsedMut,
+    {
+        let OptTarget { target, mut inner } = self;
+
+        inner.insert("target", target)?;
+
+        Ok(inner)
     }
 }
 
@@ -2866,39 +2702,60 @@ impl<Kind> markers::Base for Activity<Kind> {}
 impl<Kind> markers::Object for Activity<Kind> {}
 impl<Kind> markers::Activity for Activity<Kind> {}
 
-impl<Kind> markers::Base for ActorAndObject<Kind> {}
-impl<Kind> markers::Object for ActorAndObject<Kind> {}
-impl<Kind> markers::Activity for ActorAndObject<Kind> {}
+impl<Inner> markers::Base for ActivityActor<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for ActivityActor<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for ActivityActor<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for ActivityActor<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
-impl<Kind> markers::Base for ActorAndObjectOptTarget<Kind> {}
-impl<Kind> markers::Object for ActorAndObjectOptTarget<Kind> {}
-impl<Kind> markers::Activity for ActorAndObjectOptTarget<Kind> {}
+impl<Inner> markers::Base for ActivityObject<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for ActivityObject<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for ActivityObject<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for ActivityObject<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
-impl<Kind> markers::Base for ActorAndObjectOptOriginAndTarget<Kind> {}
-impl<Kind> markers::Object for ActorAndObjectOptOriginAndTarget<Kind> {}
-impl<Kind> markers::Activity for ActorAndObjectOptOriginAndTarget<Kind> {}
+impl<Inner> markers::Base for Target<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for Target<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for Target<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for Target<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
-impl markers::Base for Arrive {}
-impl markers::Object for Arrive {}
-impl markers::Activity for Arrive {}
-impl markers::IntransitiveActivity for Arrive {}
+impl<Inner> markers::Base for OptTarget<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for OptTarget<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for OptTarget<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for OptTarget<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
-impl markers::Base for Invite {}
-impl markers::Object for Invite {}
-impl markers::Activity for Invite {}
+impl<Inner> markers::Base for Origin<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for Origin<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for Origin<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for Origin<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
-impl markers::Base for Delete {}
-impl markers::Object for Delete {}
-impl markers::Activity for Delete {}
-
-impl markers::Base for Travel {}
-impl markers::Object for Travel {}
-impl markers::Activity for Travel {}
-impl markers::IntransitiveActivity for Travel {}
+impl<Inner> markers::Base for OptOrigin<Inner> where Inner: markers::Base {}
+impl<Inner> markers::Object for OptOrigin<Inner> where Inner: markers::Object {}
+impl<Inner> markers::Activity for OptOrigin<Inner> where Inner: markers::Activity {}
+impl<Inner> markers::IntransitiveActivity for OptOrigin<Inner> where
+    Inner: markers::IntransitiveActivity
+{
+}
 
 impl markers::Base for Question {}
 impl markers::Object for Question {}
 impl markers::Activity for Question {}
+
+impl markers::IntransitiveActivity for Arrive {}
+impl markers::IntransitiveActivity for Travel {}
 impl markers::IntransitiveActivity for Question {}
 
 impl<Inner> markers::Activity for ApObject<Inner> where Inner: markers::Activity {}
@@ -2907,15 +2764,17 @@ impl<Inner> markers::IntransitiveActivity for ApObject<Inner> where
 {
 }
 
-impl<Kind> Extends<Kind> for Activity<Kind> {
+impl<Kind> Extends for Activity<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let inner = Object::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
@@ -2937,217 +2796,273 @@ impl<Kind> TryFrom<Activity<Kind>> for Object<Kind> {
     }
 }
 
-impl<Kind> Extends<Kind> for ActorAndObject<Kind> {
+impl<Inner> Extends for ActivityActor<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
 }
 
-impl<Kind> TryFrom<Object<Kind>> for ActorAndObject<Kind> {
+impl<Inner, Kind> TryFrom<Object<Kind>> for ActivityActor<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
     type Error = serde_json::Error;
 
     fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
     }
 }
 
-impl<Kind> TryFrom<ActorAndObject<Kind>> for Object<Kind> {
+impl<Inner, Kind> TryFrom<ActivityActor<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
     type Error = serde_json::Error;
 
-    fn try_from(activity: ActorAndObject<Kind>) -> Result<Self, Self::Error> {
-        activity.retracting()
+    fn try_from(activity: ActivityActor<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
     }
 }
 
-impl Extends<ArriveType> for Arrive {
+impl<Inner> Extends for ActivityObject<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<ArriveType>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<ArriveType>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
 }
 
-impl TryFrom<Object<ArriveType>> for Arrive {
-    type Error = serde_json::Error;
-
-    fn try_from(object: Object<ArriveType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
-    }
-}
-
-impl TryFrom<Arrive> for Object<ArriveType> {
-    type Error = serde_json::Error;
-
-    fn try_from(arrive: Arrive) -> Result<Self, Self::Error> {
-        arrive.retracting()
-    }
-}
-
-impl Extends<InviteType> for Invite {
-    type Error = serde_json::Error;
-
-    fn extends(base: Base<InviteType>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
-        Self::extending(inner)
-    }
-
-    fn retracts(self) -> Result<Base<InviteType>, Self::Error> {
-        let inner = self.retracting()?;
-        inner.retracts()
-    }
-}
-
-impl TryFrom<Object<InviteType>> for Invite {
-    type Error = serde_json::Error;
-
-    fn try_from(object: Object<InviteType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
-    }
-}
-
-impl TryFrom<Invite> for Object<InviteType> {
-    type Error = serde_json::Error;
-
-    fn try_from(invite: Invite) -> Result<Self, Self::Error> {
-        invite.retracting()
-    }
-}
-
-impl Extends<DeleteType> for Delete {
-    type Error = serde_json::Error;
-
-    fn extends(base: Base<DeleteType>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
-        Self::extending(inner)
-    }
-
-    fn retracts(self) -> Result<Base<DeleteType>, Self::Error> {
-        let inner = self.retracting()?;
-        inner.retracts()
-    }
-}
-
-impl TryFrom<Object<DeleteType>> for Delete {
-    type Error = serde_json::Error;
-
-    fn try_from(object: Object<DeleteType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
-    }
-}
-
-impl TryFrom<Delete> for Object<DeleteType> {
-    type Error = serde_json::Error;
-
-    fn try_from(delete: Delete) -> Result<Self, Self::Error> {
-        delete.retracting()
-    }
-}
-
-impl<Kind> Extends<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
-    type Error = serde_json::Error;
-
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
-        Self::extending(inner)
-    }
-
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
-        let inner = self.retracting()?;
-        inner.retracts()
-    }
-}
-
-impl<Kind> TryFrom<Object<Kind>> for ActorAndObjectOptOriginAndTarget<Kind> {
+impl<Inner, Kind> TryFrom<Object<Kind>> for ActivityObject<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
     type Error = serde_json::Error;
 
     fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
     }
 }
 
-impl<Kind> TryFrom<ActorAndObjectOptOriginAndTarget<Kind>> for Object<Kind> {
+impl<Inner, Kind> TryFrom<ActivityObject<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
     type Error = serde_json::Error;
 
-    fn try_from(activity: ActorAndObjectOptOriginAndTarget<Kind>) -> Result<Self, Self::Error> {
-        activity.retracting()
+    fn try_from(activity: ActivityObject<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
     }
 }
 
-impl<Kind> Extends<Kind> for ActorAndObjectOptTarget<Kind> {
+impl<Inner> Extends for Origin<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
 }
 
-impl<Kind> TryFrom<Object<Kind>> for ActorAndObjectOptTarget<Kind> {
+impl<Inner, Kind> TryFrom<Object<Kind>> for Origin<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
     type Error = serde_json::Error;
 
     fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
     }
 }
 
-impl<Kind> TryFrom<ActorAndObjectOptTarget<Kind>> for Object<Kind> {
+impl<Inner, Kind> TryFrom<Origin<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
     type Error = serde_json::Error;
 
-    fn try_from(activity: ActorAndObjectOptTarget<Kind>) -> Result<Self, Self::Error> {
-        activity.retracting()
+    fn try_from(activity: Origin<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
     }
 }
 
-impl Extends<TravelType> for Travel {
+impl<Inner> Extends for OptOrigin<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<TravelType>) -> Result<Self, Self::Error> {
-        let inner = Object::extends(base)?;
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<TravelType>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
 }
 
-impl TryFrom<Object<TravelType>> for Travel {
+impl<Inner, Kind> TryFrom<Object<Kind>> for OptOrigin<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
     type Error = serde_json::Error;
 
-    fn try_from(object: Object<TravelType>) -> Result<Self, Self::Error> {
-        Self::extending(object)
+    fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
     }
 }
 
-impl TryFrom<Travel> for Object<TravelType> {
+impl<Inner, Kind> TryFrom<OptOrigin<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
     type Error = serde_json::Error;
 
-    fn try_from(travel: Travel) -> Result<Self, Self::Error> {
-        travel.retracting()
+    fn try_from(activity: OptOrigin<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
     }
 }
 
-impl Extends<QuestionType> for Question {
+impl<Inner> Extends for Target<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
+    type Error = serde_json::Error;
+
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
+        Self::extending(inner)
+    }
+
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
+    }
+}
+
+impl<Inner, Kind> TryFrom<Object<Kind>> for Target<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
+    }
+}
+
+impl<Inner, Kind> TryFrom<Target<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(activity: Target<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
+    }
+}
+
+impl<Inner> Extends for OptTarget<Inner>
+where
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut,
+{
+    type Kind = Inner::Kind;
+
+    type Error = serde_json::Error;
+
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::extends(base)?;
+        Self::extending(inner)
+    }
+
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
+        let inner = self.retracting()?;
+        inner.retracts()
+    }
+}
+
+impl<Inner, Kind> TryFrom<Object<Kind>> for OptTarget<Inner>
+where
+    Inner: TryFrom<Object<Kind>, Error = serde_json::Error> + UnparsedMut,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
+        let inner = Inner::try_from(object)?;
+        Self::extending(inner)
+    }
+}
+
+impl<Inner, Kind> TryFrom<OptTarget<Inner>> for Object<Kind>
+where
+    Object<Kind>: TryFrom<Inner, Error = serde_json::Error>,
+    Inner: UnparsedMut,
+{
+    type Error = serde_json::Error;
+
+    fn try_from(activity: OptTarget<Inner>) -> Result<Self, Self::Error> {
+        let inner = activity.retracting()?;
+        TryFrom::try_from(inner)
+    }
+}
+
+impl Extends for Question {
+    type Kind = QuestionType;
+
     type Error = serde_json::Error;
 
     fn extends(base: Base<QuestionType>) -> Result<Self, Self::Error> {
@@ -3183,43 +3098,55 @@ impl<Kind> UnparsedMut for Activity<Kind> {
     }
 }
 
-impl<Kind> UnparsedMut for ActorAndObject<Kind> {
+impl<Inner> UnparsedMut for ActivityActor<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
 }
 
-impl UnparsedMut for Arrive {
+impl<Inner> UnparsedMut for ActivityObject<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
 }
 
-impl UnparsedMut for Invite {
+impl<Inner> UnparsedMut for Origin<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
 }
 
-impl UnparsedMut for Delete {
+impl<Inner> UnparsedMut for OptOrigin<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
 }
 
-impl<Kind> UnparsedMut for ActorAndObjectOptOriginAndTarget<Kind> {
+impl<Inner> UnparsedMut for Target<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
 }
 
-impl<Kind> UnparsedMut for ActorAndObjectOptTarget<Kind> {
-    fn unparsed_mut(&mut self) -> &mut Unparsed {
-        self.inner.unparsed_mut()
-    }
-}
-
-impl UnparsedMut for Travel {
+impl<Inner> UnparsedMut for OptTarget<Inner>
+where
+    Inner: UnparsedMut,
+{
     fn unparsed_mut(&mut self) -> &mut Unparsed {
         self.inner.unparsed_mut()
     }
@@ -3231,437 +3158,795 @@ impl UnparsedMut for Question {
     }
 }
 
-impl<Kind> AsBase<Kind> for Activity<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for Activity<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Kind> AsObject<Kind> for Activity<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
-        &self.inner
+impl<Kind> AsObject for Activity<Kind> {
+    type Kind = Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
+        self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
-        &mut self.inner
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
+        self.inner.object_mut()
     }
 }
 
-impl<Kind> AsActivity<Kind> for Activity<Kind> {
-    fn activity_ref(&self) -> &Activity<Kind> {
+impl<Kind> AsActivity for Activity<Kind> {
+    type Kind = Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self
     }
 }
 
-impl<Kind> AsBase<Kind> for ActorAndObject<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Inner> AsBase for ActivityActor<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Kind> AsObject<Kind> for ActorAndObject<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
+impl<Inner> AsObject for ActivityActor<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> AsActivity<Kind> for ActorAndObject<Kind> {
-    fn activity_ref(&self) -> &Activity<Kind> {
-        &self.inner
-    }
+impl<Inner> AsActivity for ActivityActor<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
-        &mut self.inner
-    }
-}
-
-impl<Kind> ActorAndObjectRef for ActorAndObject<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.actor
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.object
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.actor
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.object
-    }
-}
-
-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> 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> AsActivity<Kind> for ActorAndObjectOptTarget<Kind> {
-    fn activity_ref(&self) -> &Activity<Kind> {
-        &self.inner
-    }
-
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
-        &mut self.inner
-    }
-}
-
-impl<Kind> ActorAndObjectRef for ActorAndObjectOptTarget<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.actor
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.object
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.actor
-    }
-
-    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<AnyBase>> {
-        &self.target
-    }
-
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        &mut self.target
-    }
-}
-
-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> 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> AsActivity<Kind> for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn activity_ref(&self) -> &Activity<Kind> {
-        &self.inner
-    }
-
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
-        &mut self.inner
-    }
-}
-
-impl<Kind> ActorAndObjectRef for ActorAndObjectOptOriginAndTarget<Kind> {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.actor
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.object
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.actor
-    }
-
-    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<AnyBase>> {
-        &self.target
-    }
-
-    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<AnyBase>> {
-        &self.origin
-    }
-
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        &mut self.origin
-    }
-}
-
-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 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 AsActivity<ArriveType> for Arrive {
-    fn activity_ref(&self) -> &Activity<ArriveType> {
-        &self.inner
-    }
-
-    fn activity_mut(&mut self) -> &mut Activity<ArriveType> {
-        &mut self.inner
-    }
-}
-
-impl OriginRef for Arrive {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.origin
-    }
-
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.origin
-    }
-}
-
-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 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 AsActivity<InviteType> for Invite {
-    fn activity_ref(&self) -> &Activity<InviteType> {
-        &self.inner
-    }
-
-    fn activity_mut(&mut self) -> &mut Activity<InviteType> {
-        &mut self.inner
-    }
-}
-
-impl ActorAndObjectRef for Invite {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.actor
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.object
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.actor
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.object
-    }
-}
-
-impl TargetRef for Invite {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.target
-    }
-
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.target
-    }
-}
-
-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 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 AsActivity<DeleteType> for Delete {
-    fn activity_ref(&self) -> &Activity<DeleteType> {
-        &self.inner
-    }
-
-    fn activity_mut(&mut self) -> &mut Activity<DeleteType> {
-        &mut self.inner
-    }
-}
-
-impl ActorAndObjectRef for Delete {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.actor
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        &self.object
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.actor
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        &mut self.object
-    }
-}
-
-impl OptOriginRef for Delete {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        &self.origin
-    }
-
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        &mut self.origin
-    }
-}
-
-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 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 AsActivity<TravelType> for Travel {
-    fn activity_ref(&self) -> &Activity<TravelType> {
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<TravelType> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl OptTargetRef for Travel {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        &self.target
+impl<Inner> AsActivityActor for ActivityActor<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        &mut self.target
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self
     }
 }
 
-impl OptOriginRef for Travel {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        &self.origin
+impl<Inner> AsActivityObject for ActivityActor<Inner>
+where
+    Inner: AsActivityObject,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        &mut self.origin
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl AsBase<QuestionType> for Question {
-    fn base_ref(&self) -> &Base<QuestionType> {
+impl<Inner> AsTarget for ActivityActor<Inner>
+where
+    Inner: AsTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
+    }
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
+    }
+}
+
+impl<Inner> AsOptTarget for ActivityActor<Inner>
+where
+    Inner: AsOptTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
+    }
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner> AsOrigin for ActivityActor<Inner>
+where
+    Inner: AsOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
+    }
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for ActivityActor<Inner>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
+    }
+}
+
+impl<Inner> AsBase for ActivityObject<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<QuestionType> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl AsObject<QuestionType> for Question {
-    fn object_ref(&self) -> &Object<QuestionType> {
+impl<Inner> AsObject for ActivityObject<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<QuestionType> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
 
-impl AsActivity<QuestionType> for Question {
+impl<Inner> AsActivity for ActivityObject<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
+        self.inner.activity_ref()
+    }
+
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
+        self.inner.activity_mut()
+    }
+}
+
+impl<Inner> AsActivityObject for ActivityObject<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self
+    }
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self
+    }
+}
+
+impl<Inner> AsActivityActor for ActivityObject<Inner>
+where
+    Inner: AsActivityActor,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
+    }
+
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
+    }
+}
+
+impl<Inner> AsTarget for ActivityObject<Inner>
+where
+    Inner: AsTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
+    }
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
+    }
+}
+
+impl<Inner> AsOptTarget for ActivityObject<Inner>
+where
+    Inner: AsOptTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
+    }
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner> AsOrigin for ActivityObject<Inner>
+where
+    Inner: AsOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
+    }
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for ActivityObject<Inner>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
+    }
+}
+
+impl<Inner> AsBase for Target<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner> AsObject for Target<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
+        self.inner.object_ref()
+    }
+
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
+        self.inner.object_mut()
+    }
+}
+
+impl<Inner> AsActivity for Target<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
+        self.inner.activity_ref()
+    }
+
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
+        self.inner.activity_mut()
+    }
+}
+
+impl<Inner> AsActivityObject for Target<Inner>
+where
+    Inner: AsActivityObject,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
+    }
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
+    }
+}
+
+impl<Inner> AsActivityActor for Target<Inner>
+where
+    Inner: AsActivityActor,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
+    }
+
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
+    }
+}
+
+impl<Inner> AsTarget for Target<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self
+    }
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self
+    }
+}
+
+impl<Inner> AsOrigin for Target<Inner>
+where
+    Inner: AsOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
+    }
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for Target<Inner>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
+    }
+}
+
+impl<Inner> AsBase for OptTarget<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner> AsObject for OptTarget<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
+        self.inner.object_ref()
+    }
+
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
+        self.inner.object_mut()
+    }
+}
+
+impl<Inner> AsActivity for OptTarget<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
+        self.inner.activity_ref()
+    }
+
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
+        self.inner.activity_mut()
+    }
+}
+
+impl<Inner> AsActivityObject for OptTarget<Inner>
+where
+    Inner: AsActivityObject,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
+    }
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
+    }
+}
+
+impl<Inner> AsActivityActor for OptTarget<Inner>
+where
+    Inner: AsActivityActor,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
+    }
+
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
+    }
+}
+
+impl<Inner> AsOptTarget for OptTarget<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self
+    }
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self
+    }
+}
+
+impl<Inner> AsOrigin for OptTarget<Inner>
+where
+    Inner: AsOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
+    }
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for OptTarget<Inner>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
+    }
+}
+
+impl<Inner> AsActivity for Origin<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
+        self.inner.activity_ref()
+    }
+
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
+        self.inner.activity_mut()
+    }
+}
+
+impl<Inner> AsBase for Origin<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner> AsObject for Origin<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
+        self.inner.object_ref()
+    }
+
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
+        self.inner.object_mut()
+    }
+}
+
+impl<Inner> AsActivityObject for Origin<Inner>
+where
+    Inner: AsActivityObject,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
+    }
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
+    }
+}
+
+impl<Inner> AsActivityActor for Origin<Inner>
+where
+    Inner: AsActivityActor,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
+    }
+
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
+    }
+}
+
+impl<Inner> AsTarget for Origin<Inner>
+where
+    Inner: AsTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
+    }
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
+    }
+}
+
+impl<Inner> AsOptTarget for Origin<Inner>
+where
+    Inner: AsOptTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
+    }
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner> AsOrigin for Origin<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self
+    }
+
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self
+    }
+}
+
+impl<Inner> AsBase for OptOrigin<Inner>
+where
+    Inner: AsBase,
+{
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
+        self.inner.base_ref()
+    }
+
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
+        self.inner.base_mut()
+    }
+}
+
+impl<Inner> AsObject for OptOrigin<Inner>
+where
+    Inner: AsObject,
+{
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
+        self.inner.object_ref()
+    }
+
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
+        self.inner.object_mut()
+    }
+}
+
+impl<Inner> AsActivity for OptOrigin<Inner>
+where
+    Inner: AsActivity,
+{
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
+        self.inner.activity_ref()
+    }
+
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
+        self.inner.activity_mut()
+    }
+}
+
+impl<Inner> AsActivityObject for OptOrigin<Inner>
+where
+    Inner: AsActivityObject,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
+    }
+
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
+    }
+}
+
+impl<Inner> AsActivityActor for OptOrigin<Inner>
+where
+    Inner: AsActivityActor,
+{
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
+    }
+
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
+    }
+}
+
+impl<Inner> AsTarget for OptOrigin<Inner>
+where
+    Inner: AsTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
+    }
+
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
+    }
+}
+
+impl<Inner> AsOptTarget for OptOrigin<Inner>
+where
+    Inner: AsOptTarget,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
+    }
+
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for OptOrigin<Inner>
+where
+    Inner: markers::Activity,
+{
+    type Inner = Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self
+    }
+}
+
+impl AsActivity for Question {
+    type Kind = QuestionType;
+
     fn activity_ref(&self) -> &Activity<QuestionType> {
         &self.inner
     }
@@ -3681,89 +3966,108 @@ impl AsQuestion for Question {
     }
 }
 
-impl<Inner, Kind> AsActivity<Kind> for ApObject<Inner>
+impl<Inner> AsActivity for ApObject<Inner>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner().activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner_mut().activity_mut()
     }
 }
 
-impl<Inner> ActorAndObjectRef for ApObject<Inner>
+impl<Inner> AsActivityActor for ApObject<Inner>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner().actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner().activity_actor_ref()
     }
 
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner().object_field_ref()
-    }
-
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner_mut().actor_field_mut()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner_mut().object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner_mut().activity_actor_mut()
     }
 }
 
-impl<Inner> TargetRef for ApObject<Inner>
+impl<Inner> AsActivityObject for ApObject<Inner>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner().target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner().activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner_mut().target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner_mut().activity_object_mut()
     }
 }
 
-impl<Inner> OriginRef for ApObject<Inner>
+impl<Inner> AsTarget for ApObject<Inner>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner().origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner().target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner_mut().origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner_mut().target_mut()
     }
 }
 
-impl<Inner> OptTargetRef for ApObject<Inner>
+impl<Inner> AsOrigin for ApObject<Inner>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner().target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner().origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner_mut().target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner_mut().origin_mut()
     }
 }
 
-impl<Inner> OptOriginRef for ApObject<Inner>
+impl<Inner> AsOptTarget for ApObject<Inner>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner().origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner().opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner_mut().origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner_mut().opt_target_mut()
+    }
+}
+
+impl<Inner> AsOptOrigin for ApObject<Inner>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner().opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner_mut().opt_origin_mut()
     }
 }
 
@@ -3780,12 +4084,13 @@ where
     }
 }
 
-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> ActivityExt for T where T: AsActivity {}
+impl<T> AsActivityActorExt for T where T: AsActivityActor {}
+impl<T> AsActivityObjectExt for T where T: AsActivityObject {}
+impl<T> AsTargetExt for T where T: AsTarget {}
+impl<T> AsOriginExt for T where T: AsOrigin {}
+impl<T> AsOptTargetExt for T where T: AsOptTarget {}
+impl<T> AsOptOriginExt for T where T: AsOptOrigin {}
 impl<T> QuestionExt for T where T: AsQuestion {}
 
 impl<Kind> Default for Activity<Kind>
diff --git a/src/actor.rs b/src/actor.rs
index 8142c4b..3ab5382 100644
--- a/src/actor.rs
+++ b/src/actor.rs
@@ -62,10 +62,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///
     /// let inbox_ref = person.inbox();
     /// ```
-    fn inbox<'a, Kind>(&'a self) -> Result<&'a IriString, CheckError>
+    fn inbox<'a>(&'a self) -> Result<&'a IriString, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         let inbox = self.inbox_unchecked();
         self.check_authority(inbox)
@@ -129,10 +129,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///
     /// let outbox_ref = person.outbox();
     /// ```
-    fn outbox<'a, Kind>(&'a self) -> Result<Option<&'a IriString>, CheckError>
+    fn outbox<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         self.outbox_unchecked()
             .map(|outbox| self.check_authority(outbox))
@@ -236,10 +236,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///     println!("{:?}", following);
     /// }
     /// ```
-    fn following<'a, Kind>(&'a self) -> Result<Option<&'a IriString>, CheckError>
+    fn following<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         self.following_unchecked()
             .map(|following| self.check_authority(following))
@@ -345,10 +345,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///     println!("{:?}", followers);
     /// }
     /// ```
-    fn followers<'a, Kind>(&'a self) -> Result<Option<&'a IriString>, CheckError>
+    fn followers<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         self.followers_unchecked()
             .map(|followers| self.check_authority(followers))
@@ -454,10 +454,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///     println!("{:?}", liked);
     /// }
     /// ```
-    fn liked<'a, Kind>(&'a self) -> Result<Option<&'a IriString>, CheckError>
+    fn liked<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         self.liked_unchecked()
             .map(|liked| self.check_authority(liked))
@@ -563,10 +563,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///     println!("{:?}", streams);
     /// }
     /// ```
-    fn streams<'a, Kind>(&'a self) -> Result<Option<OneOrMany<&'a IriString>>, CheckError>
+    fn streams<'a>(&'a self) -> Result<Option<OneOrMany<&'a IriString>>, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         if let Some(streams) = self.streams_unchecked() {
             for id in &streams {
@@ -810,11 +810,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     /// # Ok(())
     /// # }
     /// ```
-    fn endpoints<'a, Kind>(&'a self) -> Result<Option<Endpoints<&'a IriString>>, CheckError>
+    fn endpoints<'a>(&'a self) -> Result<Option<Endpoints<&'a IriString>>, CheckError>
     where
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
         Inner: 'a,
-        Kind: 'a,
     {
         if let Some(endpoints) = self.endpoints_unchecked() {
             let authority_opt = self.id_unchecked().and_then(|id| id.authority_components());
@@ -1416,19 +1415,20 @@ impl<Inner> markers::Actor for ApActor<Inner> where Inner: markers::Actor {}
 
 impl<Inner> markers::Actor for ApObject<Inner> where Inner: markers::Actor {}
 
-impl<Inner, Kind, Error> Extends<Kind> for ApActor<Inner>
+impl<Inner, Error> Extends for ApActor<Inner>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut + markers::Actor,
+    Inner: Extends<Error = Error> + UnparsedMut + markers::Actor,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let inner = Inner::extends(base)?;
         Ok(Self::extending(inner)?)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
@@ -1443,28 +1443,32 @@ where
     }
 }
 
-impl<Inner, Kind> AsBase<Kind> for ApActor<Inner>
+impl<Inner> AsBase for ApActor<Inner>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, Kind> AsObject<Kind> for ApActor<Inner>
+impl<Inner> AsObject for ApActor<Inner>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -1495,14 +1499,16 @@ where
     }
 }
 
-impl<Kind> Extends<Kind> for Actor<Kind> {
+impl<Kind> Extends for Actor<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         Object::extends(base).map(Actor)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         self.0.retracts()
     }
 }
@@ -1513,22 +1519,26 @@ impl<Kind> UnparsedMut for Actor<Kind> {
     }
 }
 
-impl<Kind> AsBase<Kind> for Actor<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for Actor<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.0.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.0.base_mut()
     }
 }
 
-impl<Kind> AsObject<Kind> for Actor<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
+impl<Kind> AsObject for Actor<Kind> {
+    type Kind = Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.0.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.0.object_mut()
     }
 }
diff --git a/src/base.rs b/src/base.rs
index fdd46e4..1e1008f 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -38,22 +38,24 @@ use mime::Mime;
 
 /// Implements conversion between `Base<Kind>` and other ActivityStreams objects defined in this
 /// crate
-pub trait Extends<Kind>: Sized {
+pub trait Extends: Sized {
+    type Kind;
+
     /// The erro produced must be a StdError
     type Error: std::error::Error;
 
     /// Produce an object from the Base
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error>;
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error>;
 
     /// Produce a base from the object
-    fn retracts(self) -> Result<Base<Kind>, Self::Error>;
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error>;
 }
 
 /// A helper function implemented for all Extends types to easily produce an AnyBase from a given
 /// object.
 ///
 /// This is important because many APIs in this crate deal with AnyBases.
-pub trait ExtendsExt<Kind>: Extends<Kind> {
+pub trait ExtendsExt: Extends {
     /// Create an AnyBase from the given object
     ///
     /// ```rust
@@ -68,7 +70,7 @@ pub trait ExtendsExt<Kind>: Extends<Kind> {
     /// ```
     fn into_any_base(self) -> Result<AnyBase, Self::Error>
     where
-        Kind: serde::ser::Serialize,
+        Self::Kind: serde::ser::Serialize,
         Self::Error: From<serde_json::Error>,
     {
         AnyBase::from_extended(self)
@@ -91,7 +93,7 @@ pub trait ExtendsExt<Kind>: Extends<Kind> {
     /// ```
     fn from_any_base(any_base: AnyBase) -> Result<Option<Self>, Self::Error>
     where
-        Kind: serde::de::DeserializeOwned,
+        Self::Kind: serde::de::DeserializeOwned,
         Self::Error: From<serde_json::Error>,
     {
         if let Some(base) = any_base.take_base() {
@@ -108,12 +110,14 @@ pub trait ExtendsExt<Kind>: Extends<Kind> {
 /// Implementation trait for deriving Base methods for a type
 ///
 /// Any type implementating AsBase will automatically gain methods provided by BaseExt
-pub trait AsBase<Kind>: markers::Base {
+pub trait AsBase: markers::Base {
+    type Kind;
+
     /// Immutable borrow of `Base<Kind>`
-    fn base_ref(&self) -> &Base<Kind>;
+    fn base_ref(&self) -> &Base<Self::Kind>;
 
     /// Mutable borrow of Base<Kind>
-    fn base_mut(&mut self) -> &mut Base<Kind>;
+    fn base_mut(&mut self) -> &mut Base<Self::Kind>;
 }
 
 /// Helper methods for interacting with Base types
@@ -122,7 +126,7 @@ pub trait AsBase<Kind>: markers::Base {
 /// Link or an Object.
 ///
 /// Documentation for the fields related to these methods can be found on the `Base` struct
-pub trait BaseExt<Kind>: AsBase<Kind> {
+pub trait BaseExt: AsBase {
     /// Fetch the context for the current object
     ///
     /// ```rust
@@ -135,7 +139,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn context<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().context.as_ref()
     }
@@ -277,7 +281,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn id<'a>(&'a self, host: &str, port: Option<&str>) -> Result<Option<&'a IriString>, CheckError>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.id_unchecked()
             .and_then(|id| {
@@ -306,7 +310,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn id_unchecked<'a>(&'a self) -> Option<&'a IriString>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().id.as_ref()
     }
@@ -329,7 +333,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
         port: Option<&str>,
     ) -> Result<Option<&'a mut IriString>, CheckError>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.id_mut_unchecked()
             .and_then(|id| {
@@ -358,7 +362,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn id_mut_unchecked<'a>(&'a mut self) -> Option<&'a mut IriString>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_mut().id.as_mut()
     }
@@ -445,9 +449,9 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     ///     println!("{:?}", kind);
     /// }
     /// ```
-    fn kind<'a>(&'a self) -> Option<&'a Kind>
+    fn kind<'a>(&'a self) -> Option<&'a Self::Kind>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().kind.as_ref()
     }
@@ -470,9 +474,9 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// # Ok(())
     /// # }
     /// ```
-    fn is_kind(&self, kind: &Kind) -> bool
+    fn is_kind(&self, kind: &Self::Kind) -> bool
     where
-        Kind: PartialEq,
+        Self::Kind: PartialEq,
     {
         self.kind() == Some(kind)
     }
@@ -488,7 +492,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     ///
     /// video.set_kind(VideoType::Video);
     /// ```
-    fn set_kind(&mut self, kind: Kind) -> &mut Self {
+    fn set_kind(&mut self, kind: Self::Kind) -> &mut Self {
         self.base_mut().kind = Some(kind);
         self
     }
@@ -505,7 +509,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     ///     println!("{:?}", kind);
     /// }
     /// ```
-    fn take_kind(&mut self) -> Option<Kind> {
+    fn take_kind(&mut self) -> Option<Self::Kind> {
         self.base_mut().kind.take()
     }
 
@@ -541,7 +545,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn name<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().name.as_ref().map(|o| o.as_ref())
     }
@@ -662,7 +666,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn media_type<'a>(&'a self) -> Option<&'a Mime>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().media_type.as_ref().map(|m| m.as_ref())
     }
@@ -737,7 +741,7 @@ pub trait BaseExt<Kind>: AsBase<Kind> {
     /// ```
     fn preview<'a>(&'a self) -> Option<OneOrMany<&'a AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.base_ref().preview.as_ref().map(|o| o.as_ref())
     }
@@ -1047,7 +1051,7 @@ impl<Kind> Base<Kind> {
     /// ```
     pub fn extend<T>(self) -> Result<T, T::Error>
     where
-        T: Extends<Kind>,
+        T: Extends<Kind = Kind>,
     {
         T::extends(self)
     }
@@ -1066,7 +1070,7 @@ impl<Kind> Base<Kind> {
     /// ```
     pub fn retract<T>(t: T) -> Result<Self, T::Error>
     where
-        T: Extends<Kind>,
+        T: Extends<Kind = Kind>,
     {
         t.retracts()
     }
@@ -1170,7 +1174,7 @@ impl AnyBase {
         Ok(base.into())
     }
 
-    /// Extend this AnyBase into a kind T where T implements Extends<Kind>
+    /// Extend this AnyBase into a kind T where T implements Extends
     ///
     /// This method returns Ok(None) when the AnyBase does not contain an extensible object, i.e.
     /// it's just an IRI
@@ -1186,8 +1190,8 @@ impl AnyBase {
     /// ```
     pub fn extend<T, Kind>(self) -> Result<Option<T>, T::Error>
     where
-        T: ExtendsExt<Kind>,
-        <T as Extends<Kind>>::Error: From<serde_json::Error>,
+        T: ExtendsExt<Kind = Kind>,
+        <T as Extends>::Error: From<serde_json::Error>,
         for<'de> Kind: serde::Deserialize<'de>,
     {
         T::from_any_base(self)
@@ -1205,7 +1209,7 @@ impl AnyBase {
     /// ```
     pub fn from_extended<T, Kind>(extended: T) -> Result<Self, T::Error>
     where
-        T: Extends<Kind>,
+        T: Extends<Kind = Kind>,
         T::Error: From<serde_json::Error>,
         Kind: serde::ser::Serialize,
     {
@@ -1936,35 +1940,38 @@ impl<Kind> UnparsedMut for Base<Kind> {
     }
 }
 
-impl<Kind> AsBase<Kind> for Base<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for Base<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self
     }
 }
 
-impl<Kind> Extends<Kind> for Base<Kind> {
+impl<Kind> Extends for Base<Kind> {
+    type Kind = Kind;
     type Error = std::convert::Infallible;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         Ok(base)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         Ok(self)
     }
 }
 
-impl<T, Kind> ExtendsExt<Kind> for T
+impl<T> ExtendsExt for T
 where
-    T: Extends<Kind>,
+    T: Extends,
     T::Error: From<serde_json::Error>,
 {
 }
-impl<T, Kind> BaseExt<Kind> for T where T: AsBase<Kind> {}
+impl<T> BaseExt for T where T: AsBase {}
 
 impl From<Base<serde_json::Value>> for AnyBase {
     fn from(o: Base<serde_json::Value>) -> Self {
diff --git a/src/collection.rs b/src/collection.rs
index 92e8201..f3890ad 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -38,17 +38,21 @@ use self::kind::*;
 /// Implementation trait for deriving Collection methods for a type
 ///
 /// Any type implementing AsCollection will automatically gain methods provided by CollectionExt
-pub trait AsCollection<Kind>: markers::Collection {
-    fn collection_ref(&self) -> &Collection<Kind>;
-    fn collection_mut(&mut self) -> &mut Collection<Kind>;
+pub trait AsCollection: markers::Collection {
+    type Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind>;
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind>;
 }
 
 /// Implementation trait for deriving Collection methods for a type
 ///
 /// Any type implementing AsCollectionPage will automatically gain methods provided by CollectionPageExt
-pub trait AsCollectionPage<Kind>: markers::CollectionPage {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind>;
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind>;
+pub trait AsCollectionPage: markers::CollectionPage {
+    type Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind>;
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind>;
 }
 
 /// Implementation trait for deriving Collection methods for a type
@@ -66,7 +70,7 @@ pub trait AsOrderedCollectionPage: markers::CollectionPage {
 ///
 /// Documentation for the fields related to these methods can be found on the
 /// `Collection` struct
-pub trait CollectionExt<Kind>: AsCollection<Kind> {
+pub trait CollectionExt: AsCollection {
     /// Fetch the items for the current activity
     ///
     /// ```rust
@@ -80,7 +84,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn items<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().items.as_ref()
     }
@@ -209,7 +213,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn ordered_items<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().ordered_items.as_ref()
     }
@@ -338,7 +342,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn total_items<'a>(&'a self) -> Option<u64>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().total_items
     }
@@ -408,7 +412,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn current<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().current.as_ref()
     }
@@ -484,7 +488,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn first<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().first.as_ref()
     }
@@ -560,7 +564,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
     /// ```
     fn last<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_ref().last.as_ref()
     }
@@ -629,7 +633,7 @@ pub trait CollectionExt<Kind>: AsCollection<Kind> {
 ///
 /// Documentation for the fields related to these methods can be found on the
 /// `CollectionPage` struct
-pub trait CollectionPageExt<Kind>: AsCollectionPage<Kind> {
+pub trait CollectionPageExt: AsCollectionPage {
     /// Fetch the part_of field for the current object
     ///
     /// ```rust
@@ -644,7 +648,7 @@ pub trait CollectionPageExt<Kind>: AsCollectionPage<Kind> {
     /// ```
     fn part_of<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_page_ref().part_of.as_ref()
     }
@@ -720,7 +724,7 @@ pub trait CollectionPageExt<Kind>: AsCollectionPage<Kind> {
     /// ```
     fn next<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_page_ref().next.as_ref()
     }
@@ -796,7 +800,7 @@ pub trait CollectionPageExt<Kind>: AsCollectionPage<Kind> {
     /// ```
     fn prev<'a>(&'a self) -> Option<&'a AnyBase>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.collection_page_ref().prev.as_ref()
     }
@@ -1281,15 +1285,17 @@ impl markers::CollectionPage for OrderedCollectionPage {}
 impl<Inner> markers::Collection for ApObject<Inner> where Inner: markers::Collection {}
 impl<Inner> markers::CollectionPage for ApObject<Inner> where Inner: markers::CollectionPage {}
 
-impl<Kind> Extends<Kind> for Collection<Kind> {
+impl<Kind> Extends for Collection<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let inner = Object::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
@@ -1311,15 +1317,17 @@ impl<Kind> TryFrom<Object<Kind>> for Collection<Kind> {
     }
 }
 
-impl<Kind> Extends<Kind> for CollectionPage<Kind> {
+impl<Kind> Extends for CollectionPage<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let inner = Object::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
@@ -1341,7 +1349,9 @@ impl<Kind> TryFrom<CollectionPage<Kind>> for Object<Kind> {
     }
 }
 
-impl Extends<OrderedCollectionPageType> for OrderedCollectionPage {
+impl Extends for OrderedCollectionPage {
+    type Kind = OrderedCollectionPageType;
+
     type Error = serde_json::Error;
 
     fn extends(base: Base<OrderedCollectionPageType>) -> Result<Self, Self::Error> {
@@ -1389,77 +1399,93 @@ impl UnparsedMut for OrderedCollectionPage {
     }
 }
 
-impl<Kind> AsBase<Kind> for Collection<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for Collection<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Kind> AsObject<Kind> for Collection<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
+impl<Kind> AsObject for Collection<Kind> {
+    type Kind = Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         &self.inner
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> AsCollection<Kind> for Collection<Kind> {
-    fn collection_ref(&self) -> &Collection<Kind> {
+impl<Kind> AsCollection for Collection<Kind> {
+    type Kind = Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self
     }
 }
 
-impl<Kind> AsBase<Kind> for CollectionPage<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for CollectionPage<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Kind> AsObject<Kind> for CollectionPage<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
+impl<Kind> AsObject for CollectionPage<Kind> {
+    type Kind = Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
 
-impl<Kind> AsCollection<Kind> for CollectionPage<Kind> {
-    fn collection_ref(&self) -> &Collection<Kind> {
+impl<Kind> AsCollection for CollectionPage<Kind> {
+    type Kind = Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         &self.inner
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> AsCollectionPage<Kind> for CollectionPage<Kind> {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+impl<Kind> AsCollectionPage for CollectionPage<Kind> {
+    type Kind = Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self
     }
 }
 
-impl AsBase<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsBase for OrderedCollectionPage {
+    type Kind = OrderedCollectionPageType;
+
     fn base_ref(&self) -> &Base<OrderedCollectionPageType> {
         self.inner.base_ref()
     }
@@ -1469,7 +1495,9 @@ impl AsBase<OrderedCollectionPageType> for OrderedCollectionPage {
     }
 }
 
-impl AsObject<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsObject for OrderedCollectionPage {
+    type Kind = OrderedCollectionPageType;
+
     fn object_ref(&self) -> &Object<OrderedCollectionPageType> {
         self.inner.object_ref()
     }
@@ -1479,7 +1507,9 @@ impl AsObject<OrderedCollectionPageType> for OrderedCollectionPage {
     }
 }
 
-impl AsCollection<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsCollection for OrderedCollectionPage {
+    type Kind = OrderedCollectionPageType;
+
     fn collection_ref(&self) -> &Collection<OrderedCollectionPageType> {
         self.inner.collection_ref()
     }
@@ -1489,7 +1519,9 @@ impl AsCollection<OrderedCollectionPageType> for OrderedCollectionPage {
     }
 }
 
-impl AsCollectionPage<OrderedCollectionPageType> for OrderedCollectionPage {
+impl AsCollectionPage for OrderedCollectionPage {
+    type Kind = OrderedCollectionPageType;
+
     fn collection_page_ref(&self) -> &CollectionPage<OrderedCollectionPageType> {
         &self.inner
     }
@@ -1509,28 +1541,32 @@ impl AsOrderedCollectionPage for OrderedCollectionPage {
     }
 }
 
-impl<Inner, Kind> AsCollection<Kind> for ApObject<Inner>
+impl<Inner> AsCollection for ApObject<Inner>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner().collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner_mut().collection_mut()
     }
 }
 
-impl<Inner, Kind> AsCollectionPage<Kind> for ApObject<Inner>
+impl<Inner> AsCollectionPage for ApObject<Inner>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner().collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner_mut().collection_page_mut()
     }
 }
@@ -1548,8 +1584,8 @@ where
     }
 }
 
-impl<T, Kind> CollectionExt<Kind> for T where T: AsCollection<Kind> {}
-impl<T, Kind> CollectionPageExt<Kind> for T where T: AsCollectionPage<Kind> {}
+impl<T> CollectionExt for T where T: AsCollection {}
+impl<T> CollectionPageExt for T where T: AsCollectionPage {}
 impl<T> OrderedCollectionPageExt for T where T: AsOrderedCollectionPage {}
 
 impl<Kind> Default for Collection<Kind>
diff --git a/src/lib.rs b/src/lib.rs
index 501fd15..5ef57c8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,10 @@
 //! # ActivityStreams New
 //! _A set of Traits and Types that make up the ActivityStreams and ActivityPub specifications_
 //!
-//! - Find the code on [git.asonix.dog](https://git.asonix.dog/Aardwolf/activitystreams)
+//! - Find the code on [git.asonix.dog](https://git.asonix.dog/asonix/activitystreams)
 //! - Read the docs on [docs.rs](https://docs.rs/activitystreams)
-//! - Join the matrix channel at [#activitypub:asonix.dog](https://matrix.to/#/!fAEcHyTUdAaKCzIKCt:asonix.dog?via=asonix.dog&via=matrix.org&via=t2bot.io)
-//! - Hit me up on [mastodon](https://asonix.dog/@asonix)
+//! - Join the matrix channel at [#activitypub:matrix.asonix.dog](https://matrix.to/#/!fAEcHyTUdAaKCzIKCt:asonix.dog?via=asonix.dog&via=matrix.org&via=t2bot.io)
+//! - Hit me up on [mastodon](https://masto.asonix.dog/@asonix)
 //!
 //! ## Usage
 //!
@@ -166,9 +166,9 @@
 //! ```rust
 //! use activitystreams::{base::BaseExt, context, markers::Activity, iri};
 //!
-//! fn manipulator<T, Kind>(mut activity: T) -> Result<(), anyhow::Error>
+//! fn manipulator<T>(mut activity: T) -> Result<(), anyhow::Error>
 //! where
-//!     T: Activity + BaseExt<Kind>,
+//!     T: Activity + BaseExt,
 //! {
 //!     activity
 //!         .set_id(iri!("https://example.com"))
@@ -375,8 +375,8 @@ pub mod prelude {
 
     pub use crate::{
         activity::{
-            ActivityExt, ActorAndObjectRefExt, OptOriginRefExt, OptTargetRefExt, OriginRefExt,
-            QuestionExt, TargetRefExt,
+            ActivityExt, AsActivityActorExt, AsActivityObjectExt, AsOptOriginExt, AsOptTargetExt,
+            AsOriginExt, AsTargetExt, QuestionExt,
         },
         actor::ApActorExt,
         base::{BaseExt, ExtendsExt},
diff --git a/src/link.rs b/src/link.rs
index 4a0953a..3688936 100644
--- a/src/link.rs
+++ b/src/link.rs
@@ -36,12 +36,13 @@ use self::kind::MentionType;
 /// Implementation trait for deriving Link methods for a type
 ///
 /// Any type implementing AsLink will automatically gain methods provided by LinkExt
-pub trait AsLink<Kind>: markers::Link {
+pub trait AsLink: markers::Link {
+    type Kind;
     /// Immutable borrow of `Link<Kind>`
-    fn link_ref(&self) -> &Link<Kind>;
+    fn link_ref(&self) -> &Link<Self::Kind>;
 
     /// Mutable borrow of `Link<Kind>`
-    fn link_mut(&mut self) -> &mut Link<Kind>;
+    fn link_mut(&mut self) -> &mut Link<Self::Kind>;
 }
 
 /// Helper methods for interacting with Link types
@@ -49,7 +50,7 @@ pub trait AsLink<Kind>: markers::Link {
 /// This trait represents methods valid for any ActivityStreams Link.
 ///
 /// Documentation for the fields related to these methods can be found on the `Link` struct
-pub trait LinkExt<Kind>: AsLink<Kind> {
+pub trait LinkExt: AsLink {
     /// Fetch the href for the current object
     ///
     /// ```rust
@@ -62,7 +63,7 @@ pub trait LinkExt<Kind>: AsLink<Kind> {
     /// ```
     fn href<'a>(&'a self) -> Option<&'a IriString>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.link_ref().href.as_ref()
     }
@@ -136,7 +137,7 @@ pub trait LinkExt<Kind>: AsLink<Kind> {
     /// ```
     fn hreflang<'a>(&'a self) -> Option<&'a str>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.link_ref().hreflang.as_deref()
     }
@@ -210,7 +211,7 @@ pub trait LinkExt<Kind>: AsLink<Kind> {
     /// ```
     fn rel<'a>(&'a self) -> Option<&'a OneOrMany<String>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.link_ref().rel.as_ref()
     }
@@ -330,7 +331,7 @@ pub trait LinkExt<Kind>: AsLink<Kind> {
     /// ```
     fn height<'a>(&'a self) -> Option<u64>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.link_ref().height
     }
@@ -403,7 +404,7 @@ pub trait LinkExt<Kind>: AsLink<Kind> {
     /// ```
     fn width<'a>(&'a self) -> Option<u64>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.link_ref().width
     }
@@ -618,14 +619,16 @@ impl<Kind> Link<Kind> {
 impl<Kind> markers::Base for Link<Kind> {}
 impl<Kind> markers::Link for Link<Kind> {}
 
-impl<Kind> Extends<Kind> for Link<Kind> {
+impl<Kind> Extends for Link<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         Self::extending(base)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         self.retracting()
     }
 }
@@ -658,27 +661,31 @@ impl<Kind> UnparsedMut for Link<Kind> {
     }
 }
 
-impl<Kind> AsBase<Kind> for Link<Kind> {
-    fn base_ref(&self) -> &Base<Kind> {
+impl<Kind> AsBase for Link<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         &self.inner
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> AsLink<Kind> for Link<Kind> {
-    fn link_ref(&self) -> &Link<Kind> {
+impl<Kind> AsLink for Link<Kind> {
+    type Kind = Kind;
+
+    fn link_ref(&self) -> &Link<Self::Kind> {
         self
     }
 
-    fn link_mut(&mut self) -> &mut Link<Kind> {
+    fn link_mut(&mut self) -> &mut Link<Self::Kind> {
         self
     }
 }
 
-impl<T, Kind> LinkExt<Kind> for T where T: AsLink<Kind> {}
+impl<T> LinkExt for T where T: AsLink {}
 
 impl<Kind> Default for Link<Kind>
 where
diff --git a/src/markers.rs b/src/markers.rs
index 72453f9..e27fd37 100644
--- a/src/markers.rs
+++ b/src/markers.rs
@@ -4,9 +4,9 @@
 //! use activitystreams::{base::BaseExt, markers::Activity};
 //!
 //! /// Applies the name "hi" to any given activity
-//! fn manipulator<T, Kind>(mut some_type: T) -> T
+//! fn manipulator<T>(mut some_type: T) -> T
 //! where
-//!     T: Activity + BaseExt<Kind>,
+//!     T: Activity + BaseExt,
 //! {
 //!     some_type.set_name("hi");
 //!
diff --git a/src/object.rs b/src/object.rs
index 3883b5f..97cd53f 100644
--- a/src/object.rs
+++ b/src/object.rs
@@ -36,12 +36,14 @@ use self::kind::*;
 /// Implementation trait for deriving Object methods for a type
 ///
 /// Any type implementing AsObject will automatically gain methods provided by ObjectExt
-pub trait AsObject<Kind>: markers::Object {
+pub trait AsObject: markers::Object {
+    type Kind;
+
     /// Immutable borrow of `Object<Kind>`
-    fn object_ref(&self) -> &Object<Kind>;
+    fn object_ref(&self) -> &Object<Self::Kind>;
 
     /// Mutable borrow of `Object<Kind>`
-    fn object_mut(&mut self) -> &mut Object<Kind>;
+    fn object_mut(&mut self) -> &mut Object<Self::Kind>;
 }
 
 /// Implementation trait for deriving ActivityPub Object methods for a type
@@ -105,7 +107,7 @@ pub trait AsTombstone: markers::Object {
 /// This trait represents methods valid for any ActivityStreams Object.
 ///
 /// Documentation for the fields related to these methods can be found on the `Object` struct
-pub trait ObjectExt<Kind>: AsObject<Kind> {
+pub trait ObjectExt: AsObject {
     /// Fetch the attachment for the current object
     ///
     /// ```rust
@@ -120,7 +122,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn attachment<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().attachment.as_ref()
     }
@@ -256,7 +258,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn attributed_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().attributed_to.as_ref()
     }
@@ -392,7 +394,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn audience<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().audience.as_ref()
     }
@@ -526,7 +528,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn content<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().content.as_ref().map(|o| o.as_ref())
     }
@@ -647,7 +649,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn summary<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().summary.as_ref().map(|o| o.as_ref())
     }
@@ -768,7 +770,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn url<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().url.as_ref()
     }
@@ -904,7 +906,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn generator<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().generator.as_ref()
     }
@@ -1040,7 +1042,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn icon<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().icon.as_ref()
     }
@@ -1176,7 +1178,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn image<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().image.as_ref()
     }
@@ -1312,7 +1314,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn location<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().location.as_ref()
     }
@@ -1448,7 +1450,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn tag<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().tag.as_ref()
     }
@@ -1584,7 +1586,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn start_time<'a>(&'a self) -> Option<OffsetDateTime>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref()
             .start_time
@@ -1662,7 +1664,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn end_time<'a>(&'a self) -> Option<OffsetDateTime>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref()
             .end_time
@@ -1740,7 +1742,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn duration<'a>(&'a self) -> Option<Duration>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref()
             .duration
@@ -1820,7 +1822,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn published<'a>(&'a self) -> Option<OffsetDateTime>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref()
             .published
@@ -1898,7 +1900,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn updated<'a>(&'a self) -> Option<OffsetDateTime>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref()
             .updated
@@ -1976,7 +1978,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn in_reply_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().in_reply_to.as_ref()
     }
@@ -2112,7 +2114,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn replies<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().replies.as_ref()
     }
@@ -2248,7 +2250,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().to.as_ref()
     }
@@ -2384,7 +2386,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn bto<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().bto.as_ref()
     }
@@ -2520,7 +2522,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn cc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().cc.as_ref()
     }
@@ -2656,7 +2658,7 @@ pub trait ObjectExt<Kind>: AsObject<Kind> {
     /// ```
     fn bcc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
     where
-        Kind: 'a,
+        Self::Kind: 'a,
     {
         self.object_ref().bcc.as_ref()
     }
@@ -5131,14 +5133,16 @@ impl Tombstone {
     }
 }
 
-impl<Kind> Extends<Kind> for Object<Kind> {
+impl<Kind> Extends for Object<Kind> {
+    type Kind = Kind;
+
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         Self::extending(base)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         self.retracting()
     }
 }
@@ -5159,24 +5163,26 @@ impl<Kind> TryFrom<Object<Kind>> for Base<Kind> {
     }
 }
 
-impl<Inner, Kind> Extends<Kind> for ApObject<Inner>
+impl<Inner> Extends for ApObject<Inner>
 where
-    Inner: Extends<Kind, Error = serde_json::Error> + UnparsedMut + markers::Object,
+    Inner: Extends<Error = serde_json::Error> + UnparsedMut + markers::Object,
 {
+    type Kind = Inner::Kind;
     type Error = serde_json::Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let inner = Inner::extends(base)?;
         Self::extending(inner)
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let inner = self.retracting()?;
         inner.retracts()
     }
 }
 
-impl Extends<PlaceType> for Place {
+impl Extends for Place {
+    type Kind = PlaceType;
     type Error = serde_json::Error;
 
     fn extends(base: Base<PlaceType>) -> Result<Self, Self::Error> {
@@ -5206,7 +5212,8 @@ impl TryFrom<Place> for Object<PlaceType> {
     }
 }
 
-impl Extends<ProfileType> for Profile {
+impl Extends for Profile {
+    type Kind = ProfileType;
     type Error = serde_json::Error;
 
     fn extends(base: Base<ProfileType>) -> Result<Self, Self::Error> {
@@ -5236,7 +5243,8 @@ impl TryFrom<Profile> for Object<ProfileType> {
     }
 }
 
-impl Extends<RelationshipType> for Relationship {
+impl Extends for Relationship {
+    type Kind = RelationshipType;
     type Error = serde_json::Error;
 
     fn extends(base: Base<RelationshipType>) -> Result<Self, Self::Error> {
@@ -5266,7 +5274,9 @@ impl TryFrom<Relationship> for Object<RelationshipType> {
     }
 }
 
-impl Extends<TombstoneType> for Tombstone {
+impl Extends for Tombstone {
+    type Kind = TombstoneType;
+
     type Error = serde_json::Error;
 
     fn extends(base: Base<TombstoneType>) -> Result<Self, Self::Error> {
@@ -5353,55 +5363,63 @@ 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, Kind> ObjectExt for T where T: AsObject<Kind = 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> {
+impl<Kind> AsBase for Object<Kind> {
+    type Kind = Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         &self.inner
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         &mut self.inner
     }
 }
 
-impl<Kind> AsObject<Kind> for Object<Kind> {
-    fn object_ref(&self) -> &Object<Kind> {
+impl<Kind> AsObject for Object<Kind> {
+    type Kind = Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self
     }
 }
 
-impl<Inner, Kind> AsBase<Kind> for ApObject<Inner>
+impl<Inner> AsBase for ApObject<Inner>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, Kind> AsObject<Kind> for ApObject<Inner>
+impl<Inner> AsObject for ApObject<Inner>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -5471,7 +5489,9 @@ where
     }
 }
 
-impl AsBase<PlaceType> for Place {
+impl AsBase for Place {
+    type Kind = PlaceType;
+
     fn base_ref(&self) -> &Base<PlaceType> {
         self.inner.base_ref()
     }
@@ -5481,7 +5501,9 @@ impl AsBase<PlaceType> for Place {
     }
 }
 
-impl AsObject<PlaceType> for Place {
+impl AsObject for Place {
+    type Kind = PlaceType;
+
     fn object_ref(&self) -> &Object<PlaceType> {
         &self.inner
     }
@@ -5501,7 +5523,9 @@ impl AsPlace for Place {
     }
 }
 
-impl AsBase<ProfileType> for Profile {
+impl AsBase for Profile {
+    type Kind = ProfileType;
+
     fn base_ref(&self) -> &Base<ProfileType> {
         self.inner.base_ref()
     }
@@ -5511,7 +5535,9 @@ impl AsBase<ProfileType> for Profile {
     }
 }
 
-impl AsObject<ProfileType> for Profile {
+impl AsObject for Profile {
+    type Kind = ProfileType;
+
     fn object_ref(&self) -> &Object<ProfileType> {
         &self.inner
     }
@@ -5531,7 +5557,9 @@ impl AsProfile for Profile {
     }
 }
 
-impl AsBase<RelationshipType> for Relationship {
+impl AsBase for Relationship {
+    type Kind = RelationshipType;
+
     fn base_ref(&self) -> &Base<RelationshipType> {
         self.inner.base_ref()
     }
@@ -5541,7 +5569,9 @@ impl AsBase<RelationshipType> for Relationship {
     }
 }
 
-impl AsObject<RelationshipType> for Relationship {
+impl AsObject for Relationship {
+    type Kind = RelationshipType;
+
     fn object_ref(&self) -> &Object<RelationshipType> {
         &self.inner
     }
@@ -5561,7 +5591,9 @@ impl AsRelationship for Relationship {
     }
 }
 
-impl AsBase<TombstoneType> for Tombstone {
+impl AsBase for Tombstone {
+    type Kind = TombstoneType;
+
     fn base_ref(&self) -> &Base<TombstoneType> {
         self.inner.base_ref()
     }
@@ -5571,7 +5603,9 @@ impl AsBase<TombstoneType> for Tombstone {
     }
 }
 
-impl AsObject<TombstoneType> for Tombstone {
+impl AsObject for Tombstone {
+    type Kind = TombstoneType;
+
     fn object_ref(&self) -> &Object<TombstoneType> {
         &self.inner
     }
diff --git a/src/unparsed.rs b/src/unparsed.rs
index b1c8e93..e2f74fe 100644
--- a/src/unparsed.rs
+++ b/src/unparsed.rs
@@ -46,13 +46,14 @@
 //!
 //! /// Then, we'll implement Extends so we can produce a PublicKey<Object> from an AnyBase.
 //!
-//! impl<Inner, Kind> Extends<Kind> for PublicKey<Inner>
+//! impl<Inner> Extends for PublicKey<Inner>
 //! where
-//!     Inner: Extends<Kind, Error=serde_json::Error> + UnparsedMut,
+//!     Inner: Extends<Error=serde_json::Error> + UnparsedMut,
 //! {
+//!     type Kind = Inner::Kind;
 //!     type Error = serde_json::Error;
 //!
-//!     fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+//!     fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
 //!         let mut inner = Inner::extends(base)?;
 //!
 //!         Ok(PublicKey {
@@ -61,7 +62,7 @@
 //!         })
 //!     }
 //!
-//!     fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+//!     fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
 //!         let PublicKey {
 //!             public_key,
 //!             mut inner,
@@ -87,15 +88,17 @@
 //! ///
 //! /// This allows us to access methods related to `context`, `id`, `kind`, `name`,
 //! /// `media_type`, and `preview` directly from the PublicKey struct
-//! impl<Inner, Kind> AsBase<Kind> for PublicKey<Inner>
+//! impl<Inner> AsBase for PublicKey<Inner>
 //! where
-//!     Inner: AsBase<Kind>,
+//!     Inner: AsBase,
 //! {
-//!     fn base_ref(&self) -> &Base<Kind> {
+//!     type Kind = Inner::Kind;
+//!
+//!     fn base_ref(&self) -> &Base<Self::Kind> {
 //!         self.inner.base_ref()
 //!     }
 //!
-//!     fn base_mut(&mut self) -> &mut Base<Kind> {
+//!     fn base_mut(&mut self) -> &mut Base<Self::Kind> {
 //!         self.inner.base_mut()
 //!     }
 //! }
@@ -104,15 +107,17 @@
 //! ///
 //! /// This allows us to access methods related to `url`, `generator`, `start_time`, `duration`,
 //! /// and more directly from the PublicKey struct
-//! impl<Inner, Kind> AsObject<Kind> for PublicKey<Inner>
+//! impl<Inner> AsObject for PublicKey<Inner>
 //! where
-//!     Inner: AsObject<Kind>,
+//!     Inner: AsObject,
 //! {
-//!     fn object_ref(&self) -> &Object<Kind> {
+//!     type Kind = Inner::Kind;
+//!
+//!     fn object_ref(&self) -> &Object<Self::Kind> {
 //!         self.inner.object_ref()
 //!     }
 //!
-//!     fn object_mut(&mut self) -> &mut Object<Kind> {
+//!     fn object_mut(&mut self) -> &mut Object<Self::Kind> {
 //!         self.inner.object_mut()
 //!     }
 //! }