Use of associated types + Identity and EmailSubmission helpers.

src/core/changes.rs

@@ -1,6 +1,10 @@
 use serde::{Deserialize, Serialize};
 
-use super::RequestParams;
+use super::{Object, RequestParams};
+
+pub trait ChangesObject: Object {
+    type ChangesResponse;
+}
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ChangesRequest {
@@ -16,7 +20,7 @@ pub struct ChangesRequest {
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ChangesResponse<A> {
+pub struct ChangesResponse<O: ChangesObject> {
     #[serde(rename = "accountId")]
     account_id: String,
 
@@ -36,7 +40,7 @@ pub struct ChangesResponse<A> {
     destroyed: Vec<String>,
 
     #[serde(flatten)]
-    arguments: A,
+    arguments: O::ChangesResponse,
 }
 
 impl ChangesRequest {
@@ -59,7 +63,7 @@ impl ChangesRequest {
     }
 }
 
-impl<A> ChangesResponse<A> {
+impl<O: ChangesObject> ChangesResponse<O> {
     pub fn account_id(&self) -> &str {
         &self.account_id
     }
@@ -88,7 +92,7 @@ impl<A> ChangesResponse<A> {
         &self.destroyed
     }
 
-    pub fn arguments(&self) -> &A {
+    pub fn arguments(&self) -> &O::ChangesResponse {
         &self.arguments
     }
 }

src/core/copy.rs

@@ -1,14 +1,14 @@
-use std::{collections::HashMap, fmt::Display};
+use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
 use super::{
-    set::{Create, SetError},
+    set::{SetError, SetObject},
     RequestParams,
 };
 
 #[derive(Debug, Clone, Serialize)]
-pub struct CopyRequest<T: Create> {
+pub struct CopyRequest<O: SetObject> {
     #[serde(rename = "fromAccountId")]
     from_account_id: String,
 
@@ -24,7 +24,7 @@ pub struct CopyRequest<T: Create> {
     if_in_state: Option<String>,
 
     #[serde(rename = "create")]
-    create: HashMap<String, T>,
+    create: HashMap<String, O>,
 
     #[serde(rename = "onSuccessDestroyOriginal")]
     on_success_destroy_original: bool,
@@ -35,7 +35,7 @@ pub struct CopyRequest<T: Create> {
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct CopyResponse<T, U: Display> {
+pub struct CopyResponse<O: SetObject> {
     #[serde(rename = "fromAccountId")]
     from_account_id: String,
 
@@ -49,13 +49,13 @@ pub struct CopyResponse<T, U: Display> {
     new_state: String,
 
     #[serde(rename = "created")]
-    created: Option<HashMap<String, T>>,
+    created: Option<HashMap<String, O>>,
 
     #[serde(rename = "notCreated")]
-    not_created: Option<HashMap<String, SetError<U>>>,
+    not_created: Option<HashMap<String, SetError<O::Property>>>,
 }
 
-impl<T: Create> CopyRequest<T> {
+impl<T: SetObject> CopyRequest<T> {
     pub fn new(params: RequestParams, from_account_id: String) -> Self {
         CopyRequest {
             from_account_id,
@@ -105,7 +105,7 @@ impl<T: Create> CopyRequest<T> {
     }
 }
 
-impl<T, U: Display> CopyResponse<T, U> {
+impl<O: SetObject> CopyResponse<O> {
     pub fn from_account_id(&self) -> &str {
         &self.from_account_id
     }
@@ -122,11 +122,11 @@ impl<T, U: Display> CopyResponse<T, U> {
         &self.new_state
     }
 
-    pub fn created(&self, id: &str) -> Option<&T> {
+    pub fn created(&self, id: &str) -> Option<&O> {
         self.created.as_ref().and_then(|created| created.get(id))
     }
 
-    pub fn not_created(&self, id: &str) -> Option<&SetError<U>> {
+    pub fn not_created(&self, id: &str) -> Option<&SetError<O::Property>> {
         self.not_created
             .as_ref()
             .and_then(|not_created| not_created.get(id))

src/core/get.rs

@@ -1,13 +1,15 @@
-use std::fmt::Display;
-
 use serde::{Deserialize, Serialize};
 
 use crate::Method;
 
-use super::{request::ResultReference, RequestParams, Type};
+use super::{request::ResultReference, Object, RequestParams};
+
+pub trait GetObject: Object {
+    type GetArguments: Default;
+}
 
 #[derive(Debug, Clone, Serialize)]
-pub struct GetRequest<T: Display + Type, A: Default> {
+pub struct GetRequest<O: GetObject> {
     #[serde(skip)]
     method: (Method, usize),
 
@@ -24,10 +26,10 @@ pub struct GetRequest<T: Display + Type, A: Default> {
     ids_ref: Option<ResultReference>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    properties: Option<Vec<T>>,
+    properties: Option<Vec<O::Property>>,
 
     #[serde(flatten)]
-    arguments: A,
+    arguments: O::GetArguments,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -43,10 +45,10 @@ pub struct GetResponse<T> {
     not_found: Vec<String>,
 }
 
-impl<T: Display + Type, A: Default> GetRequest<T, A> {
+impl<O: GetObject> GetRequest<O> {
     pub fn new(params: RequestParams) -> Self {
         GetRequest {
-            account_id: if T::requires_account_id() {
+            account_id: if O::requires_account_id() {
                 params.account_id.into()
             } else {
                 None
@@ -55,12 +57,12 @@ impl<T: Display + Type, A: Default> GetRequest<T, A> {
             ids: None,
             ids_ref: None,
             properties: None,
-            arguments: A::default(),
+            arguments: O::GetArguments::default(),
         }
     }
 
     pub fn account_id(&mut self, account_id: impl Into<String>) -> &mut Self {
-        if T::requires_account_id() {
+        if O::requires_account_id() {
             self.account_id = Some(account_id.into());
         }
         self
@@ -82,16 +84,16 @@ impl<T: Display + Type, A: Default> GetRequest<T, A> {
         self
     }
 
-    pub fn properties(&mut self, properties: impl IntoIterator<Item = T>) -> &mut Self {
+    pub fn properties(&mut self, properties: impl IntoIterator<Item = O::Property>) -> &mut Self {
         self.properties = Some(properties.into_iter().collect());
         self
     }
 
-    pub fn arguments(&mut self) -> &mut A {
+    pub fn arguments(&mut self) -> &mut O::GetArguments {
         &mut self.arguments
     }
 
-    pub fn result_reference(&self, property: T) -> ResultReference {
+    pub fn result_reference(&self, property: O::Property) -> ResultReference {
         ResultReference::new(
             self.method.0,
             self.method.1,
@@ -100,7 +102,7 @@ impl<T: Display + Type, A: Default> GetRequest<T, A> {
     }
 }
 
-impl<T> GetResponse<T> {
+impl<O> GetResponse<O> {
     pub fn account_id(&self) -> &str {
         self.account_id.as_ref().unwrap()
     }
@@ -109,7 +111,7 @@ impl<T> GetResponse<T> {
         &self.state
     }
 
-    pub fn list(&self) -> &[T] {
+    pub fn list(&self) -> &[O] {
         &self.list
     }
 
@@ -117,10 +119,10 @@ impl<T> GetResponse<T> {
         &self.not_found
     }
 
-    pub fn unwrap_list(&mut self) -> Vec<T> {
+    pub fn unwrap_list(&mut self) -> Vec<O> {
         std::mem::take(&mut self.list)
     }
-    pub fn pop(&mut self) -> Option<T> {
+    pub fn pop(&mut self) -> Option<O> {
         self.list.pop()
     }
 

src/core/mod.rs

@@ -1,3 +1,7 @@
+use std::fmt::Display;
+
+use serde::{Deserialize, Serialize};
+
 use crate::Method;
 
 pub mod changes;
@@ -27,6 +31,7 @@ impl RequestParams {
     }
 }
 
-pub trait Type {
+pub trait Object: Sized {
+    type Property: Display + Serialize + for<'de> Deserialize<'de>;
     fn requires_account_id() -> bool;
 }

src/core/query.rs

@@ -2,10 +2,16 @@ use serde::{Deserialize, Serialize};
 
 use crate::Method;
 
-use super::{request::ResultReference, RequestParams};
+use super::{request::ResultReference, Object, RequestParams};
+
+pub trait QueryObject: Object {
+    type QueryArguments: Default + Serialize;
+    type Filter: Serialize;
+    type Sort: Serialize;
+}
 
 #[derive(Debug, Clone, Serialize)]
-pub struct QueryRequest<F, S, A: Default> {
+pub struct QueryRequest<O: QueryObject> {
     #[serde(skip)]
     method: (Method, usize),
 
@@ -14,11 +20,11 @@ pub struct QueryRequest<F, S, A: Default> {
 
     #[serde(rename = "filter")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    filter: Option<Filter<F>>,
+    filter: Option<Filter<O::Filter>>,
 
     #[serde(rename = "sort")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    sort: Option<Vec<Comparator<S>>>,
+    sort: Option<Vec<Comparator<O::Sort>>>,
 
     #[serde(rename = "position")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -41,7 +47,7 @@ pub struct QueryRequest<F, S, A: Default> {
     calculate_total: Option<bool>,
 
     #[serde(flatten)]
-    arguments: A,
+    arguments: O::QueryArguments,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -103,7 +109,7 @@ pub struct QueryResponse {
     limit: Option<usize>,
 }
 
-impl<F, S, A: Default> QueryRequest<F, S, A> {
+impl<O: QueryObject> QueryRequest<O> {
     pub fn new(params: RequestParams) -> Self {
         QueryRequest {
             account_id: params.account_id,
@@ -115,7 +121,7 @@ impl<F, S, A: Default> QueryRequest<F, S, A> {
             anchor_offset: None,
             limit: None,
             calculate_total: None,
-            arguments: A::default(),
+            arguments: O::QueryArguments::default(),
         }
     }
 
@@ -124,12 +130,12 @@ impl<F, S, A: Default> QueryRequest<F, S, A> {
         self
     }
 
-    pub fn filter(&mut self, filter: impl Into<Filter<F>>) -> &mut Self {
+    pub fn filter(&mut self, filter: impl Into<Filter<O::Filter>>) -> &mut Self {
         self.filter = Some(filter.into());
         self
     }
 
-    pub fn sort(&mut self, sort: impl IntoIterator<Item = Comparator<S>>) -> &mut Self {
+    pub fn sort(&mut self, sort: impl IntoIterator<Item = Comparator<O::Sort>>) -> &mut Self {
         self.sort = Some(sort.into_iter().collect());
         self
     }
@@ -159,7 +165,7 @@ impl<F, S, A: Default> QueryRequest<F, S, A> {
         self
     }
 
-    pub fn arguments(&mut self) -> &mut A {
+    pub fn arguments(&mut self) -> &mut O::QueryArguments {
         &mut self.arguments
     }
 

src/core/query_changes.rs

@@ -1,22 +1,22 @@
 use serde::{Deserialize, Serialize};
 
 use super::{
-    query::{Comparator, Filter},
+    query::{Comparator, Filter, QueryObject},
     RequestParams,
 };
 
 #[derive(Debug, Clone, Serialize)]
-pub struct QueryChangesRequest<F, S, A: Default> {
+pub struct QueryChangesRequest<O: QueryObject> {
     #[serde(rename = "accountId")]
     account_id: String,
 
     #[serde(rename = "filter")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    filter: Option<Filter<F>>,
+    filter: Option<Filter<O::Filter>>,
 
     #[serde(rename = "sort")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    sort: Option<Vec<Comparator<S>>>,
+    sort: Option<Vec<Comparator<O::Sort>>>,
 
     #[serde(rename = "sinceQueryState")]
     since_query_state: String,
@@ -33,7 +33,7 @@ pub struct QueryChangesRequest<F, S, A: Default> {
     calculate_total: bool,
 
     #[serde(flatten)]
-    arguments: A,
+    arguments: O::QueryArguments,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -58,7 +58,7 @@ pub struct AddedItem {
     index: usize,
 }
 
-impl<F, S, A: Default> QueryChangesRequest<F, S, A> {
+impl<O: QueryObject> QueryChangesRequest<O> {
     pub fn new(params: RequestParams, since_query_state: String) -> Self {
         QueryChangesRequest {
             account_id: params.account_id,
@@ -68,7 +68,7 @@ impl<F, S, A: Default> QueryChangesRequest<F, S, A> {
             max_changes: None,
             up_to_id: None,
             calculate_total: false,
-            arguments: A::default(),
+            arguments: O::QueryArguments::default(),
         }
     }
 
@@ -77,12 +77,12 @@ impl<F, S, A: Default> QueryChangesRequest<F, S, A> {
         self
     }
 
-    pub fn filter(&mut self, filter: impl Into<Filter<F>>) -> &mut Self {
+    pub fn filter(&mut self, filter: impl Into<Filter<O::Filter>>) -> &mut Self {
         self.filter = Some(filter.into());
         self
     }
 
-    pub fn sort(&mut self, sort: impl IntoIterator<Item = Comparator<S>>) -> &mut Self {
+    pub fn sort(&mut self, sort: impl IntoIterator<Item = Comparator<O::Sort>>) -> &mut Self {
         self.sort = Some(sort.into_iter().collect());
         self
     }
@@ -102,7 +102,7 @@ impl<F, S, A: Default> QueryChangesRequest<F, S, A> {
         self
     }
 
-    pub fn arguments(&mut self) -> &mut A {
+    pub fn arguments(&mut self) -> &mut O::QueryArguments {
         &mut self.arguments
     }
 }

src/core/request.rs

@@ -5,13 +5,13 @@ use serde::{de::DeserializeOwned, Serialize};
 use crate::{
     blob::copy::CopyBlobRequest,
     client::Client,
-    email::{self, import::EmailImportRequest, parse::EmailParseRequest, Email},
+    email::{import::EmailImportRequest, parse::EmailParseRequest, Email},
-    email_submission::{self, EmailSubmission},
+    email_submission::EmailSubmission,
-    identity::{self, Identity},
+    identity::Identity,
-    mailbox::{self, Mailbox},
+    mailbox::Mailbox,
-    push_subscription::{self, PushSubscription},
+    push_subscription::PushSubscription,
-    thread,
+    thread::Thread,
-    vacation_response::{self, VacationResponse},
+    vacation_response::VacationResponse,
     Error, Method, Set, URI,
 };
 
@@ -55,47 +55,29 @@ pub struct ResultReference {
 #[serde(untagged)]
 pub enum Arguments {
     Changes(ChangesRequest),
-    PushGet(GetRequest<push_subscription::Property, ()>),
+    PushGet(GetRequest<PushSubscription<Set>>),
-    PushSet(SetRequest<PushSubscription<Set>, ()>),
+    PushSet(SetRequest<PushSubscription<Set>>),
     BlobCopy(CopyBlobRequest),
-    MailboxGet(GetRequest<mailbox::Property, ()>),
+    MailboxGet(GetRequest<Mailbox<Set>>),
-    MailboxQuery(
+    MailboxQuery(QueryRequest<Mailbox<Set>>),
-        QueryRequest<mailbox::query::Filter, mailbox::query::Comparator, mailbox::QueryArguments>,
+    MailboxQueryChanges(QueryChangesRequest<Mailbox<Set>>),
-    ),
+    MailboxSet(SetRequest<Mailbox<Set>>),
-    MailboxQueryChanges(
+    ThreadGet(GetRequest<Thread>),
-        QueryChangesRequest<
+    EmailGet(GetRequest<Email<Set>>),
-            mailbox::query::Filter,
+    EmailQuery(QueryRequest<Email<Set>>),
-            mailbox::query::Comparator,
+    EmailQueryChanges(QueryChangesRequest<Email<Set>>),
-            mailbox::QueryArguments,
+    EmailSet(SetRequest<Email<Set>>),
-        >,
-    ),
-    MailboxSet(SetRequest<Mailbox<Set>, mailbox::SetArguments>),
-    ThreadGet(GetRequest<thread::Property, ()>),
-    EmailGet(GetRequest<email::Property, email::GetArguments>),
-    EmailQuery(QueryRequest<email::query::Filter, email::query::Comparator, email::QueryArguments>),
-    EmailQueryChanges(
-        QueryChangesRequest<email::query::Filter, email::query::Comparator, email::QueryArguments>,
-    ),
-    EmailSet(SetRequest<Email<Set>, ()>),
     EmailCopy(CopyRequest<Email<Set>>),
     EmailImport(EmailImportRequest),
     EmailParse(EmailParseRequest),
-    IdentityGet(GetRequest<identity::Property, ()>),
+    IdentityGet(GetRequest<Identity<Set>>),
-    IdentitySet(SetRequest<Identity<Set>, ()>),
+    IdentitySet(SetRequest<Identity<Set>>),
-    EmailSubmissionGet(GetRequest<email_submission::Property, ()>),
+    EmailSubmissionGet(GetRequest<EmailSubmission<Set>>),
-    EmailSubmissionQuery(
+    EmailSubmissionQuery(QueryRequest<EmailSubmission<Set>>),
-        QueryRequest<email_submission::query::Filter, email_submission::query::Comparator, ()>,
+    EmailSubmissionQueryChanges(QueryChangesRequest<EmailSubmission<Set>>),
-    ),
+    EmailSubmissionSet(SetRequest<EmailSubmission<Set>>),
-    EmailSubmissionQueryChanges(
+    VacationResponseGet(GetRequest<VacationResponse<Set>>),
-        QueryChangesRequest<
+    VacationResponseSet(SetRequest<VacationResponse<Set>>),
-            email_submission::query::Filter,
-            email_submission::query::Comparator,
-            (),
-        >,
-    ),
-    EmailSubmissionSet(SetRequest<EmailSubmission<Set>, email_submission::SetArguments>),
-    VacationResponseGet(GetRequest<vacation_response::Property, ()>),
-    VacationResponseSet(SetRequest<VacationResponse<Set>, ()>),
 }
 
 impl Arguments {
@@ -205,14 +187,14 @@ impl Arguments {
         }
     }
 
-    pub fn push_get_mut(&mut self) -> &mut GetRequest<push_subscription::Property, ()> {
+    pub fn push_get_mut(&mut self) -> &mut GetRequest<PushSubscription<Set>> {
         match self {
             Arguments::PushGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn push_set_mut(&mut self) -> &mut SetRequest<PushSubscription<Set>, ()> {
+    pub fn push_set_mut(&mut self) -> &mut SetRequest<PushSubscription<Set>> {
         match self {
             Arguments::PushSet(ref mut r) => r,
             _ => unreachable!(),
@@ -226,84 +208,63 @@ impl Arguments {
         }
     }
 
-    pub fn mailbox_get_mut(&mut self) -> &mut GetRequest<mailbox::Property, ()> {
+    pub fn mailbox_get_mut(&mut self) -> &mut GetRequest<Mailbox<Set>> {
         match self {
             Arguments::MailboxGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn mailbox_query_mut(
+    pub fn mailbox_query_mut(&mut self) -> &mut QueryRequest<Mailbox<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<
-        mailbox::query::Filter,
-        mailbox::query::Comparator,
-        mailbox::QueryArguments,
-    > {
         match self {
             Arguments::MailboxQuery(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn mailbox_query_changes_mut(
+    pub fn mailbox_query_changes_mut(&mut self) -> &mut QueryChangesRequest<Mailbox<Set>> {
-        &mut self,
-    ) -> &mut QueryChangesRequest<
-        mailbox::query::Filter,
-        mailbox::query::Comparator,
-        mailbox::QueryArguments,
-    > {
         match self {
             Arguments::MailboxQueryChanges(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn mailbox_set_mut(&mut self) -> &mut SetRequest<Mailbox<Set>, mailbox::SetArguments> {
+    pub fn mailbox_set_mut(&mut self) -> &mut SetRequest<Mailbox<Set>> {
         match self {
             Arguments::MailboxSet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn thread_get_mut(&mut self) -> &mut GetRequest<thread::Property, ()> {
+    pub fn thread_get_mut(&mut self) -> &mut GetRequest<Thread> {
         match self {
             Arguments::ThreadGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_get_mut(&mut self) -> &mut GetRequest<email::Property, email::GetArguments> {
+    pub fn email_get_mut(&mut self) -> &mut GetRequest<Email<Set>> {
         match self {
             Arguments::EmailGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_query_mut(
+    pub fn email_query_mut(&mut self) -> &mut QueryRequest<Email<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<email::query::Filter, email::query::Comparator, email::QueryArguments>
-    {
         match self {
             Arguments::EmailQuery(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_query_changes_mut(
+    pub fn email_query_changes_mut(&mut self) -> &mut QueryChangesRequest<Email<Set>> {
-        &mut self,
-    ) -> &mut QueryChangesRequest<
-        email::query::Filter,
-        email::query::Comparator,
-        email::QueryArguments,
-    > {
         match self {
             Arguments::EmailQueryChanges(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_set_mut(&mut self) -> &mut SetRequest<Email<Set>, ()> {
+    pub fn email_set_mut(&mut self) -> &mut SetRequest<Email<Set>> {
         match self {
             Arguments::EmailSet(ref mut r) => r,
             _ => unreachable!(),
@@ -331,31 +292,28 @@ impl Arguments {
         }
     }
 
-    pub fn identity_get_mut(&mut self) -> &mut GetRequest<identity::Property, ()> {
+    pub fn identity_get_mut(&mut self) -> &mut GetRequest<Identity<Set>> {
         match self {
             Arguments::IdentityGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn identity_set_mut(&mut self) -> &mut SetRequest<Identity<Set>, ()> {
+    pub fn identity_set_mut(&mut self) -> &mut SetRequest<Identity<Set>> {
         match self {
             Arguments::IdentitySet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_submission_get_mut(&mut self) -> &mut GetRequest<email_submission::Property, ()> {
+    pub fn email_submission_get_mut(&mut self) -> &mut GetRequest<EmailSubmission<Set>> {
         match self {
             Arguments::EmailSubmissionGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_submission_query_mut(
+    pub fn email_submission_query_mut(&mut self) -> &mut QueryRequest<EmailSubmission<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<email_submission::query::Filter, email_submission::query::Comparator, ()>
-    {
         match self {
             Arguments::EmailSubmissionQuery(ref mut r) => r,
             _ => unreachable!(),
@@ -364,36 +322,28 @@ impl Arguments {
 
     pub fn email_submission_query_changes_mut(
         &mut self,
-    ) -> &mut QueryChangesRequest<
+    ) -> &mut QueryChangesRequest<EmailSubmission<Set>> {
-        email_submission::query::Filter,
-        email_submission::query::Comparator,
-        (),
-    > {
         match self {
             Arguments::EmailSubmissionQueryChanges(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn email_submission_set_mut(
+    pub fn email_submission_set_mut(&mut self) -> &mut SetRequest<EmailSubmission<Set>> {
-        &mut self,
-    ) -> &mut SetRequest<EmailSubmission<Set>, email_submission::SetArguments> {
         match self {
             Arguments::EmailSubmissionSet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn vacation_response_get_mut(
+    pub fn vacation_response_get_mut(&mut self) -> &mut GetRequest<VacationResponse<Set>> {
-        &mut self,
-    ) -> &mut GetRequest<vacation_response::Property, ()> {
         match self {
             Arguments::VacationResponseGet(ref mut r) => r,
             _ => unreachable!(),
         }
     }
 
-    pub fn vacation_response_set_mut(&mut self) -> &mut SetRequest<VacationResponse<Set>, ()> {
+    pub fn vacation_response_set_mut(&mut self) -> &mut SetRequest<VacationResponse<Set>> {
         match self {
             Arguments::VacationResponseSet(ref mut r) => r,
             _ => unreachable!(),

src/core/response.rs

@@ -4,13 +4,13 @@ use serde::{de::Visitor, Deserialize};
 
 use crate::{
     blob::copy::CopyBlobResponse,
-    email::{self, import::EmailImportResponse, parse::EmailParseResponse, Email},
+    email::{import::EmailImportResponse, parse::EmailParseResponse, Email},
-    email_submission::{self, EmailSubmission},
+    email_submission::EmailSubmission,
-    identity::{self, Identity},
+    identity::Identity,
-    mailbox::{self, Mailbox},
+    mailbox::Mailbox,
-    push_subscription::{self, PushSubscription},
+    push_subscription::PushSubscription,
     thread::Thread,
-    vacation_response::{self, VacationResponse},
+    vacation_response::VacationResponse,
     Get, Method,
 };
 
@@ -93,28 +93,26 @@ pub enum Error {
     Error,
 }
 
-pub type PushSubscriptionSetResponse =
+pub type PushSubscriptionSetResponse = SetResponse<PushSubscription<Get>>;
-    SetResponse<PushSubscription<Get>, push_subscription::Property>;
 pub type PushSubscriptionGetResponse = GetResponse<PushSubscription<Get>>;
-pub type MaiboxChangesResponse = ChangesResponse<mailbox::ChangesResponse>;
+pub type MaiboxChangesResponse = ChangesResponse<Mailbox<Get>>;
-pub type MailboxSetResponse = SetResponse<Mailbox<Get>, mailbox::Property>;
+pub type MailboxSetResponse = SetResponse<Mailbox<Get>>;
 pub type MailboxGetResponse = GetResponse<Mailbox<Get>>;
 pub type ThreadGetResponse = GetResponse<Thread>;
-pub type ThreadChangesResponse = ChangesResponse<()>;
+pub type ThreadChangesResponse = ChangesResponse<Thread>;
 pub type EmailGetResponse = GetResponse<Email<Get>>;
-pub type EmailSetResponse = SetResponse<Email<Get>, email::Property>;
+pub type EmailSetResponse = SetResponse<Email<Get>>;
-pub type EmailCopyResponse = CopyResponse<Email<Get>, email::Property>;
+pub type EmailCopyResponse = CopyResponse<Email<Get>>;
-pub type EmailChangesResponse = ChangesResponse<()>;
+pub type EmailChangesResponse = ChangesResponse<Email<Get>>;
 pub type SearchSnippetGetResponse = GetResponse<String>;
-pub type IdentitySetResponse = SetResponse<Identity<Get>, identity::Property>;
+pub type IdentitySetResponse = SetResponse<Identity<Get>>;
 pub type IdentityGetResponse = GetResponse<Identity<Get>>;
-pub type IdentityChangesResponse = ChangesResponse<()>;
+pub type IdentityChangesResponse = ChangesResponse<Identity<Get>>;
-pub type EmailSubmissionSetResponse = SetResponse<EmailSubmission<Get>, email_submission::Property>;
+pub type EmailSubmissionSetResponse = SetResponse<EmailSubmission<Get>>;
 pub type EmailSubmissionGetResponse = GetResponse<EmailSubmission<Get>>;
-pub type EmailSubmissionChangesResponse = ChangesResponse<()>;
+pub type EmailSubmissionChangesResponse = ChangesResponse<EmailSubmission<Get>>;
 pub type VacationResponseGetResponse = GetResponse<VacationResponse<Get>>;
-pub type VacationResponseSetResponse =
+pub type VacationResponseSetResponse = SetResponse<VacationResponse<Get>>;
-    SetResponse<VacationResponse<Get>, vacation_response::Property>;
 
 #[derive(Debug)]
 pub struct TaggedMethodResponse {

src/core/set.rs

@@ -7,10 +7,17 @@ use std::{
 
 use crate::Error;
 
-use super::{request::ResultReference, RequestParams, Type};
+use super::{request::ResultReference, Object, RequestParams};
+
+pub trait SetObject: Object {
+    type SetArguments: Default;
+
+    fn new(create_id: Option<usize>) -> Self;
+    fn create_id(&self) -> Option<String>;
+}
 
 #[derive(Debug, Clone, Serialize)]
-pub struct SetRequest<T: Create + Type, A: Default> {
+pub struct SetRequest<O: SetObject> {
     #[serde(rename = "accountId")]
     #[serde(skip_serializing_if = "Option::is_none")]
     account_id: Option<String>,
@@ -20,10 +27,10 @@ pub struct SetRequest<T: Create + Type, A: Default> {
     if_in_state: Option<String>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    create: Option<HashMap<String, T>>,
+    create: Option<HashMap<String, O>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    update: Option<HashMap<String, T>>,
+    update: Option<HashMap<String, O>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     destroy: Option<Vec<String>>,
@@ -34,11 +41,11 @@ pub struct SetRequest<T: Create + Type, A: Default> {
     destroy_ref: Option<ResultReference>,
 
     #[serde(flatten)]
-    arguments: A,
+    arguments: O::SetArguments,
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct SetResponse<T, U: Display> {
+pub struct SetResponse<O: SetObject> {
     #[serde(rename = "accountId")]
     account_id: Option<String>,
 
@@ -49,22 +56,22 @@ pub struct SetResponse<T, U: Display> {
     new_state: Option<String>,
 
     #[serde(rename = "created")]
-    created: Option<HashMap<String, T>>,
+    created: Option<HashMap<String, O>>,
 
     #[serde(rename = "updated")]
-    updated: Option<HashMap<String, Option<T>>>,
+    updated: Option<HashMap<String, Option<O>>>,
 
     #[serde(rename = "destroyed")]
     destroyed: Option<Vec<String>>,
 
     #[serde(rename = "notCreated")]
-    not_created: Option<HashMap<String, SetError<U>>>,
+    not_created: Option<HashMap<String, SetError<O::Property>>>,
 
     #[serde(rename = "notUpdated")]
-    not_updated: Option<HashMap<String, SetError<U>>>,
+    not_updated: Option<HashMap<String, SetError<O::Property>>>,
 
     #[serde(rename = "notDestroyed")]
-    not_destroyed: Option<HashMap<String, SetError<U>>>,
+    not_destroyed: Option<HashMap<String, SetError<O::Property>>>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -126,15 +133,10 @@ pub enum SetErrorType {
     CannotUnsend,
 }
 
-pub trait Create: Sized {
+impl<O: SetObject> SetRequest<O> {
-    fn new(create_id: Option<usize>) -> Self;
-    fn create_id(&self) -> Option<String>;
-}
-
-impl<T: Create + Type, A: Default> SetRequest<T, A> {
     pub fn new(params: RequestParams) -> Self {
         Self {
-            account_id: if T::requires_account_id() {
+            account_id: if O::requires_account_id() {
                 params.account_id.into()
             } else {
                 None
@@ -149,7 +151,7 @@ impl<T: Create + Type, A: Default> SetRequest<T, A> {
     }
 
     pub fn account_id(&mut self, account_id: impl Into<String>) -> &mut Self {
-        if T::requires_account_id() {
+        if O::requires_account_id() {
             self.account_id = Some(account_id.into());
         }
         self
@@ -160,12 +162,12 @@ impl<T: Create + Type, A: Default> SetRequest<T, A> {
         self
     }
 
-    pub fn create(&mut self) -> &mut T {
+    pub fn create(&mut self) -> &mut O {
         let create_id = self.create.as_ref().map_or(0, |c| c.len());
         let create_id_str = format!("c{}", create_id);
         self.create
             .get_or_insert_with(HashMap::new)
-            .insert(create_id_str.clone(), T::new(create_id.into()));
+            .insert(create_id_str.clone(), O::new(create_id.into()));
         self.create
             .as_mut()
             .unwrap()
@@ -173,7 +175,7 @@ impl<T: Create + Type, A: Default> SetRequest<T, A> {
             .unwrap()
     }
 
-    pub fn create_item(&mut self, item: T) -> String {
+    pub fn create_item(&mut self, item: O) -> String {
         let create_id = self.create.as_ref().map_or(0, |c| c.len());
         let create_id_str = format!("c{}", create_id);
         self.create
@@ -182,15 +184,15 @@ impl<T: Create + Type, A: Default> SetRequest<T, A> {
         create_id_str
     }
 
-    pub fn update(&mut self, id: impl Into<String>) -> &mut T {
+    pub fn update(&mut self, id: impl Into<String>) -> &mut O {
         let id: String = id.into();
         self.update
             .get_or_insert_with(HashMap::new)
-            .insert(id.clone(), T::new(None));
+            .insert(id.clone(), O::new(None));
         self.update.as_mut().unwrap().get_mut(&id).unwrap()
     }
 
-    pub fn update_item(&mut self, id: impl Into<String>, item: T) {
+    pub fn update_item(&mut self, id: impl Into<String>, item: O) {
         self.update
             .get_or_insert_with(HashMap::new)
             .insert(id.into(), item);
@@ -214,12 +216,12 @@ impl<T: Create + Type, A: Default> SetRequest<T, A> {
         self
     }
 
-    pub fn arguments(&mut self) -> &mut A {
+    pub fn arguments(&mut self) -> &mut O::SetArguments {
         &mut self.arguments
     }
 }
 
-impl<T, U: Display> SetResponse<T, U> {
+impl<O: SetObject> SetResponse<O> {
     pub fn account_id(&self) -> &str {
         self.account_id.as_ref().unwrap()
     }
@@ -232,7 +234,7 @@ impl<T, U: Display> SetResponse<T, U> {
         self.new_state.as_ref().unwrap()
     }
 
-    pub fn created(&mut self, id: &str) -> crate::Result<T> {
+    pub fn created(&mut self, id: &str) -> crate::Result<O> {
         if let Some(result) = self.created.as_mut().and_then(|r| r.remove(id)) {
             Ok(result)
         } else if let Some(error) = self.not_created.as_mut().and_then(|r| r.remove(id)) {
@@ -242,7 +244,7 @@ impl<T, U: Display> SetResponse<T, U> {
         }
     }
 
-    pub fn updated(&mut self, id: &str) -> crate::Result<Option<T>> {
+    pub fn updated(&mut self, id: &str) -> crate::Result<Option<O>> {
         if let Some(result) = self.updated.as_mut().and_then(|r| r.remove(id)) {
             Ok(result)
         } else if let Some(error) = self.not_updated.as_mut().and_then(|r| r.remove(id)) {
@@ -378,6 +380,6 @@ pub fn date_not_set(date: &Option<DateTime<Utc>>) -> bool {
     matches!(date, Some(date) if date.timestamp() == 0)
 }
 
-pub fn list_not_set<T>(list: &Option<Vec<T>>) -> bool {
+pub fn list_not_set<O>(list: &Option<Vec<O>>) -> bool {
     matches!(list, Some(list) if list.is_empty() )
 }

src/email/get.rs

@@ -1,8 +1,8 @@
-use crate::Get;
+use crate::{core::get::GetObject, Get, Set};
 
 use super::{
-    Email, EmailAddress, EmailAddressGroup, EmailBodyPart, EmailBodyValue, EmailHeader, Header,
+    Email, EmailAddress, EmailAddressGroup, EmailBodyPart, EmailBodyValue, EmailHeader,
-    HeaderValue,
+    GetArguments, Header, HeaderValue,
 };
 
 impl Email<Get> {
@@ -229,3 +229,11 @@ impl EmailHeader<Get> {
         self.value.as_str()
     }
 }
+
+impl GetObject for Email<Set> {
+    type GetArguments = GetArguments;
+}
+
+impl GetObject for Email<Get> {
+    type GetArguments = GetArguments;
+}

src/email/helpers.rs

@@ -10,7 +10,7 @@ use crate::{
         response::{EmailCopyResponse, EmailGetResponse, EmailSetResponse},
         set::SetRequest,
     },
-    Method, Set,
+    Get, Method, Set,
 };
 
 use super::{
@@ -118,7 +118,7 @@ impl Client {
         &mut self,
         id: &str,
         properties: Option<impl IntoIterator<Item = Property>>,
-    ) -> crate::Result<Option<Email>> {
+    ) -> crate::Result<Option<Email<Get>>> {
         let mut request = self.build();
         let get_request = request.get_email().ids([id]);
         if let Some(properties) = properties {
@@ -134,7 +134,7 @@ impl Client {
         &mut self,
         since_state: impl Into<String>,
         max_changes: usize,
-    ) -> crate::Result<ChangesResponse<()>> {
+    ) -> crate::Result<ChangesResponse<Email<Get>>> {
         let mut request = self.build();
         request.changes_email(since_state).max_changes(max_changes);
         request.send_single().await
@@ -187,7 +187,7 @@ impl Client {
 }
 
 impl Request<'_> {
-    pub fn get_email(&mut self) -> &mut GetRequest<super::Property, super::GetArguments> {
+    pub fn get_email(&mut self) -> &mut GetRequest<Email<Set>> {
         self.add_method_call(
             Method::GetEmail,
             Arguments::email_get(self.params(Method::GetEmail)),
@@ -207,14 +207,11 @@ impl Request<'_> {
         .changes_mut()
     }
 
-    pub async fn send_changes_email(self) -> crate::Result<ChangesResponse<()>> {
+    pub async fn send_changes_email(self) -> crate::Result<ChangesResponse<Email<Get>>> {
         self.send_single().await
     }
 
-    pub fn query_email(
+    pub fn query_email(&mut self) -> &mut QueryRequest<Email<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<super::query::Filter, super::query::Comparator, super::QueryArguments>
-    {
         self.add_method_call(
             Method::QueryEmail,
             Arguments::email_query(self.params(Method::QueryEmail)),
@@ -229,11 +226,7 @@ impl Request<'_> {
     pub fn query_email_changes(
         &mut self,
         since_query_state: impl Into<String>,
-    ) -> &mut QueryChangesRequest<
+    ) -> &mut QueryChangesRequest<Email<Set>> {
-        super::query::Filter,
-        super::query::Comparator,
-        super::QueryArguments,
-    > {
         self.add_method_call(
             Method::QueryChangesEmail,
             Arguments::email_query_changes(
@@ -248,7 +241,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_email(&mut self) -> &mut SetRequest<Email<Set>, ()> {
+    pub fn set_email(&mut self) -> &mut SetRequest<Email<Set>> {
         self.add_method_call(
             Method::SetEmail,
             Arguments::email_set(self.params(Method::SetEmail)),

src/email/mod.rs

@@ -14,10 +14,34 @@ use std::{
 };
 
 use crate::{
-    core::{request::ResultReference, Type},
+    core::{changes::ChangesObject, request::ResultReference, Object},
     Get, Set,
 };
 
+impl Object for Email<Set> {
+    type Property = Property;
+
+    fn requires_account_id() -> bool {
+        true
+    }
+}
+
+impl Object for Email<Get> {
+    type Property = Property;
+
+    fn requires_account_id() -> bool {
+        true
+    }
+}
+
+impl ChangesObject for Email<Set> {
+    type ChangesResponse = ();
+}
+
+impl ChangesObject for Email<Get> {
+    type ChangesResponse = ();
+}
+
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct Email<State = Get> {
     #[serde(skip)]
@@ -816,18 +840,6 @@ impl SubmissionCapabilities {
     }
 }
 
-impl Type for Email<Set> {
-    fn requires_account_id() -> bool {
-        true
-    }
-}
-
-impl Type for Property {
-    fn requires_account_id() -> bool {
-        true
-    }
-}
-
 #[cfg(feature = "debug")]
 use std::collections::BTreeMap;
 

src/email/query.rs

@@ -1,7 +1,15 @@
 use chrono::{DateTime, Utc};
 use serde::Serialize;
 
-use crate::core::{query, set::from_timestamp};
+use crate::{
+    core::{
+        query::{self, QueryObject},
+        set::from_timestamp,
+    },
+    Set,
+};
+
+use super::{Email, QueryArguments};
 
 #[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
@@ -279,3 +287,11 @@ impl Comparator {
         })
     }
 }
+
+impl QueryObject for Email<Set> {
+    type QueryArguments = QueryArguments;
+
+    type Filter = Filter;
+
+    type Sort = Comparator;
+}

src/email/set.rs

@@ -3,9 +3,9 @@ use std::collections::HashMap;
 use crate::{
     core::{
         request::ResultReference,
-        set::{from_timestamp, Create},
+        set::{from_timestamp, SetObject},
     },
-    Set,
+    Get, Set,
 };
 
 use super::{
@@ -177,7 +177,9 @@ impl Email<Set> {
     }
 }
 
-impl Create for Email<Set> {
+impl SetObject for Email<Set> {
+    type SetArguments = ();
+
     fn new(_create_id: Option<usize>) -> Email<Set> {
         Email {
             _create_id,
@@ -218,6 +220,18 @@ impl Create for Email<Set> {
     }
 }
 
+impl SetObject for Email<Get> {
+    type SetArguments = ();
+
+    fn new(_create_id: Option<usize>) -> Email<Get> {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}
+
 impl EmailBodyPart {
     pub fn new() -> EmailBodyPart<Set> {
         EmailBodyPart {

src/email_submission/get.rs

@@ -1,4 +1,4 @@
-use crate::Get;
+use crate::{Get, core::get::GetObject, Set};
 
 use super::{Address, Delivered, DeliveryStatus, Displayed, EmailSubmission, UndoStatus};
 
@@ -78,3 +78,11 @@ impl DeliveryStatus {
         &self.displayed
     }
 }
+
+impl GetObject for EmailSubmission<Set> {
+    type GetArguments = ();
+}
+
+impl GetObject for EmailSubmission<Get> {
+    type GetArguments = ();
+}

src/email_submission/helpers.rs

@@ -1,20 +1,137 @@
 use crate::{
+    client::Client,
     core::{
         changes::{ChangesRequest, ChangesResponse},
         get::GetRequest,
-        query::{QueryRequest, QueryResponse},
+        query::{Comparator, Filter, QueryRequest, QueryResponse},
         query_changes::{QueryChangesRequest, QueryChangesResponse},
         request::{Arguments, Request},
         response::{EmailSubmissionGetResponse, EmailSubmissionSetResponse},
-        set::SetRequest,
+        set::{SetObject, SetRequest},
     },
-    Method, Set, URI,
+    Get, Method, Set, URI,
 };
 
-use super::EmailSubmission;
+use super::{Address, EmailSubmission, Property, UndoStatus};
+
+impl Client {
+    pub async fn email_submission_create(
+        &mut self,
+        email_id: impl Into<String>,
+        identity_id: impl Into<String>,
+    ) -> crate::Result<EmailSubmission<Get>> {
+        let mut request = self.build();
+        let id = request
+            .set_email_submission()
+            .create()
+            .email_id(email_id)
+            .identity_id(identity_id)
+            .create_id()
+            .unwrap();
+        request
+            .send_single::<EmailSubmissionSetResponse>()
+            .await?
+            .created(&id)
+    }
+
+    pub async fn email_submission_create_envelope<T, U>(
+        &mut self,
+        email_id: impl Into<String>,
+        identity_id: impl Into<String>,
+        mail_from: U,
+        rcpt_to: T,
+    ) -> crate::Result<EmailSubmission<Get>>
+    where
+        T: IntoIterator<Item = U>,
+        U: Into<Address>,
+    {
+        let mut request = self.build();
+        let id = request
+            .set_email_submission()
+            .create()
+            .email_id(email_id)
+            .identity_id(identity_id)
+            .envelope(mail_from, rcpt_to)
+            .create_id()
+            .unwrap();
+        request
+            .send_single::<EmailSubmissionSetResponse>()
+            .await?
+            .created(&id)
+    }
+
+    pub async fn email_submission_change_status(
+        &mut self,
+        id: &str,
+        undo_status: UndoStatus,
+    ) -> crate::Result<Option<EmailSubmission>> {
+        let mut request = self.build();
+        request
+            .set_email_submission()
+            .update(id)
+            .undo_status(undo_status);
+        request
+            .send_single::<EmailSubmissionSetResponse>()
+            .await?
+            .updated(id)
+    }
+
+    pub async fn email_submission_destroy(&mut self, id: &str) -> crate::Result<()> {
+        let mut request = self.build();
+        request.set_email_submission().destroy([id]);
+        request
+            .send_single::<EmailSubmissionSetResponse>()
+            .await?
+            .destroyed(id)
+    }
+
+    pub async fn email_submission_get(
+        &mut self,
+        id: &str,
+        properties: Option<Vec<Property>>,
+    ) -> crate::Result<Option<EmailSubmission>> {
+        let mut request = self.build();
+        let get_request = request.get_email_submission().ids([id]);
+        if let Some(properties) = properties {
+            get_request.properties(properties.into_iter());
+        }
+        request
+            .send_single::<EmailSubmissionGetResponse>()
+            .await
+            .map(|mut r| r.unwrap_list().pop())
+    }
+
+    pub async fn email_submission_query(
+        &mut self,
+        filter: Option<impl Into<Filter<super::query::Filter>>>,
+        sort: Option<impl IntoIterator<Item = Comparator<super::query::Comparator>>>,
+    ) -> crate::Result<QueryResponse> {
+        let mut request = self.build();
+        let query_request = request.query_email_submission();
+        if let Some(filter) = filter {
+            query_request.filter(filter);
+        }
+        if let Some(sort) = sort {
+            query_request.sort(sort.into_iter());
+        }
+        request.send_single::<QueryResponse>().await
+    }
+
+    pub async fn email_submission_changes(
+        &mut self,
+        since_state: impl Into<String>,
+        max_changes: usize,
+    ) -> crate::Result<ChangesResponse<EmailSubmission<Get>>> {
+        let mut request = self.build();
+        request
+            .changes_email_submission(since_state)
+            .max_changes(max_changes);
+        request.send_single().await
+    }
+}
 
 impl Request<'_> {
-    pub fn get_email_submission(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_email_submission(&mut self) -> &mut GetRequest<EmailSubmission<Set>> {
         self.add_capability(URI::Submission);
         self.add_method_call(
             Method::GetEmailSubmission,
@@ -42,13 +159,13 @@ impl Request<'_> {
         .changes_mut()
     }
 
-    pub async fn send_changes_email_submission(self) -> crate::Result<ChangesResponse<()>> {
+    pub async fn send_changes_email_submission(
+        self,
+    ) -> crate::Result<ChangesResponse<EmailSubmission<Get>>> {
         self.send_single().await
     }
 
-    pub fn query_email_submission(
+    pub fn query_email_submission(&mut self) -> &mut QueryRequest<EmailSubmission<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<super::query::Filter, super::query::Comparator, ()> {
         self.add_capability(URI::Submission);
         self.add_method_call(
             Method::QueryEmailSubmission,
@@ -64,7 +181,7 @@ impl Request<'_> {
     pub fn query_email_submission_changes(
         &mut self,
         since_query_state: impl Into<String>,
-    ) -> &mut QueryChangesRequest<super::query::Filter, super::query::Comparator, ()> {
+    ) -> &mut QueryChangesRequest<EmailSubmission<Set>> {
         self.add_capability(URI::Submission);
         self.add_method_call(
             Method::QueryChangesEmailSubmission,
@@ -80,9 +197,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_email_submission(
+    pub fn set_email_submission(&mut self) -> &mut SetRequest<EmailSubmission<Set>> {
-        &mut self,
-    ) -> &mut SetRequest<EmailSubmission<Set>, super::SetArguments> {
         self.add_capability(URI::Submission);
         self.add_method_call(
             Method::SetEmailSubmission,

src/email_submission/mod.rs

@@ -8,7 +8,11 @@ use std::{collections::HashMap, fmt::Display};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
-use crate::{core::Type, email::Email, Get, Set};
+use crate::{
+    core::{changes::ChangesObject, Object},
+    email::Email,
+    Get, Set,
+};
 
 #[derive(Debug, Clone, Serialize, Default)]
 pub struct SetArguments {
@@ -168,14 +172,26 @@ impl Display for Property {
     }
 }
 
-impl Type for EmailSubmission<Set> {
+impl Object for EmailSubmission<Set> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
 
-impl Type for Property {
+impl Object for EmailSubmission<Get> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
+
+impl ChangesObject for EmailSubmission<Set> {
+    type ChangesResponse = ();
+}
+
+impl ChangesObject for EmailSubmission<Get> {
+    type ChangesResponse = ();
+}

src/email_submission/query.rs

@@ -1,9 +1,15 @@
 use chrono::{DateTime, Utc};
 use serde::Serialize;
 
-use crate::core::{query, set::from_timestamp};
+use crate::{
+    core::{
+        query::{self, QueryObject},
+        set::from_timestamp,
+    },
+    Set,
+};
 
-use super::UndoStatus;
+use super::{EmailSubmission, UndoStatus};
 
 #[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
@@ -106,3 +112,11 @@ impl Comparator {
         query::Comparator::new(Comparator::SentAt)
     }
 }
+
+impl QueryObject for EmailSubmission<Set> {
+    type QueryArguments = ();
+
+    type Filter = Filter;
+
+    type Sort = Comparator;
+}

src/email_submission/set.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::{core::set::Create, Set};
+use crate::{core::set::SetObject, Get, Set};
 
 use super::{Address, EmailSubmission, Envelope, UndoStatus};
 
@@ -17,12 +17,12 @@ impl EmailSubmission<Set> {
 
     pub fn envelope<T, U>(&mut self, mail_from: U, rcpt_to: T) -> &mut Self
     where
-        T: Iterator<Item = U>,
+        T: IntoIterator<Item = U>,
         U: Into<Address>,
     {
         self.envelope = Some(Envelope {
             mail_from: mail_from.into(),
-            rcpt_to: rcpt_to.map(|s| s.into()).collect(),
+            rcpt_to: rcpt_to.into_iter().map(|s| s.into()).collect(),
         });
         self
     }
@@ -33,7 +33,9 @@ impl EmailSubmission<Set> {
     }
 }
 
-impl Create for EmailSubmission<Set> {
+impl SetObject for EmailSubmission<Set> {
+    type SetArguments = ();
+
     fn new(_create_id: Option<usize>) -> Self {
         EmailSubmission {
             _create_id,
@@ -56,6 +58,18 @@ impl Create for EmailSubmission<Set> {
     }
 }
 
+impl SetObject for EmailSubmission<Get> {
+    type SetArguments = ();
+
+    fn new(_create_id: Option<usize>) -> Self {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}
+
 impl Address {
     pub fn new(email: String) -> Address<Set> {
         Address {

src/identity/get.rs

@@ -1,4 +1,4 @@
-use crate::{email::EmailAddress, Get};
+use crate::{core::get::GetObject, email::EmailAddress, Get, Set};
 
 use super::Identity;
 
@@ -7,6 +7,10 @@ impl Identity<Get> {
         self.id.as_ref().unwrap()
     }
 
+    pub fn unwrap_id(self) -> String {
+        self.id.unwrap()
+    }
+
     pub fn name(&self) -> Option<&str> {
         self.name.as_deref()
     }
@@ -35,3 +39,11 @@ impl Identity<Get> {
         self.may_delete.unwrap_or(false)
     }
 }
+
+impl GetObject for Identity<Set> {
+    type GetArguments = ();
+}
+
+impl GetObject for Identity<Get> {
+    type GetArguments = ();
+}

src/identity/helpers.rs

@@ -1,17 +1,77 @@
 use crate::{
+    client::Client,
     core::{
+        changes::{ChangesRequest, ChangesResponse},
         get::GetRequest,
         request::{Arguments, Request},
         response::{IdentityGetResponse, IdentitySetResponse},
-        set::SetRequest,
+        set::{SetObject, SetRequest},
     },
-    Method, Set,
+    Get, Method, Set,
 };
 
-use super::Identity;
+use super::{Identity, Property};
+
+impl Client {
+    pub async fn identity_create(
+        &mut self,
+        name: impl Into<String>,
+        email: impl Into<String>,
+    ) -> crate::Result<Identity> {
+        let mut request = self.build();
+        let id = request
+            .set_identity()
+            .create()
+            .name(name)
+            .email(email)
+            .create_id()
+            .unwrap();
+        request
+            .send_single::<IdentitySetResponse>()
+            .await?
+            .created(&id)
+    }
+
+    pub async fn identity_destroy(&mut self, id: &str) -> crate::Result<()> {
+        let mut request = self.build();
+        request.set_identity().destroy([id]);
+        request
+            .send_single::<IdentitySetResponse>()
+            .await?
+            .destroyed(id)
+    }
+
+    pub async fn identity_get(
+        &mut self,
+        id: &str,
+        properties: Option<Vec<Property>>,
+    ) -> crate::Result<Option<Identity>> {
+        let mut request = self.build();
+        let get_request = request.get_identity().ids([id]);
+        if let Some(properties) = properties {
+            get_request.properties(properties.into_iter());
+        }
+        request
+            .send_single::<IdentityGetResponse>()
+            .await
+            .map(|mut r| r.unwrap_list().pop())
+    }
+
+    pub async fn identity_changes(
+        &mut self,
+        since_state: impl Into<String>,
+        max_changes: usize,
+    ) -> crate::Result<ChangesResponse<Identity<Get>>> {
+        let mut request = self.build();
+        request
+            .changes_identity(since_state)
+            .max_changes(max_changes);
+        request.send_single().await
+    }
+}
 
 impl Request<'_> {
-    pub fn get_identity(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_identity(&mut self) -> &mut GetRequest<Identity<Set>> {
         self.add_method_call(
             Method::GetIdentity,
             Arguments::identity_get(self.params(Method::GetIdentity)),
@@ -23,7 +83,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_identity(&mut self) -> &mut SetRequest<Identity<Set>, ()> {
+    pub fn set_identity(&mut self) -> &mut SetRequest<Identity<Set>> {
         self.add_method_call(
             Method::SetIdentity,
             Arguments::identity_set(self.params(Method::SetIdentity)),
@@ -34,4 +94,16 @@ impl Request<'_> {
     pub async fn send_set_identity(self) -> crate::Result<IdentitySetResponse> {
         self.send_single().await
     }
+
+    pub fn changes_identity(&mut self, since_state: impl Into<String>) -> &mut ChangesRequest {
+        self.add_method_call(
+            Method::ChangesIdentity,
+            Arguments::changes(self.params(Method::ChangesIdentity), since_state.into()),
+        )
+        .changes_mut()
+    }
+
+    pub async fn send_changes_identity(self) -> crate::Result<ChangesResponse<Identity<Get>>> {
+        self.send_single().await
+    }
 }

src/identity/mod.rs

@@ -4,8 +4,9 @@ pub mod set;
 
 use std::fmt::Display;
 
+use crate::core::changes::ChangesObject;
 use crate::core::set::list_not_set;
-use crate::core::Type;
+use crate::core::Object;
 use crate::Set;
 use crate::{email::EmailAddress, Get};
 use serde::{Deserialize, Serialize};
@@ -86,14 +87,26 @@ impl Display for Property {
     }
 }
 
-impl Type for Identity<Set> {
+impl Object for Identity<Set> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
 
-impl Type for Property {
+impl Object for Identity<Get> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
+
+impl ChangesObject for Identity<Set> {
+    type ChangesResponse = ();
+}
+
+impl ChangesObject for Identity<Get> {
+    type ChangesResponse = ();
+}

src/identity/set.rs

@@ -1,15 +1,15 @@
-use crate::{core::set::Create, email::EmailAddress, Set};
+use crate::{core::set::SetObject, email::EmailAddress, Get, Set};
 
 use super::Identity;
 
 impl Identity<Set> {
-    pub fn name(&mut self, name: String) -> &mut Self {
+    pub fn name(&mut self, name: impl Into<String>) -> &mut Self {
-        self.name = Some(name);
+        self.name = Some(name.into());
         self
     }
 
-    pub fn email(&mut self, email: String) -> &mut Self {
+    pub fn email(&mut self, email: impl Into<String>) -> &mut Self {
-        self.email = Some(email);
+        self.email = Some(email.into());
         self
     }
 
@@ -31,18 +31,20 @@ impl Identity<Set> {
         self
     }
 
-    pub fn text_signature(&mut self, text_signature: String) -> &mut Self {
+    pub fn text_signature(&mut self, text_signature: impl Into<String>) -> &mut Self {
-        self.text_signature = Some(text_signature);
+        self.text_signature = Some(text_signature.into());
         self
     }
 
-    pub fn html_signature(&mut self, html_signature: String) -> &mut Self {
+    pub fn html_signature(&mut self, html_signature: impl Into<String>) -> &mut Self {
-        self.html_signature = Some(html_signature);
+        self.html_signature = Some(html_signature.into());
         self
     }
 }
 
-impl Create for Identity<Set> {
+impl SetObject for Identity<Set> {
+    type SetArguments = ();
+
     fn new(_create_id: Option<usize>) -> Self {
         Identity {
             _create_id,
@@ -62,3 +64,15 @@ impl Create for Identity<Set> {
         self._create_id.map(|id| format!("c{}", id))
     }
 }
+
+impl SetObject for Identity<Get> {
+    type SetArguments = ();
+
+    fn new(_create_id: Option<usize>) -> Self {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}

src/mailbox/get.rs

@@ -1,4 +1,4 @@
-use crate::Get;
+use crate::{core::get::GetObject, Get, Set};
 
 use super::{Mailbox, Role};
 
@@ -83,3 +83,11 @@ impl Mailbox<Get> {
         self.my_rights.as_ref().unwrap().may_submit
     }
 }
+
+impl GetObject for Mailbox<Set> {
+    type GetArguments = ();
+}
+
+impl GetObject for Mailbox<Get> {
+    type GetArguments = ();
+}

src/mailbox/helpers.rs

@@ -7,9 +7,9 @@ use crate::{
         query_changes::{QueryChangesRequest, QueryChangesResponse},
         request::{Arguments, Request},
         response::{MailboxGetResponse, MailboxSetResponse},
-        set::{Create, SetRequest},
+        set::{SetObject, SetRequest},
     },
-    Method, Set,
+    Get, Method, Set,
 };
 
 use super::{Mailbox, Property, Role};
@@ -137,7 +137,7 @@ impl Client {
         &mut self,
         since_state: impl Into<String>,
         max_changes: usize,
-    ) -> crate::Result<ChangesResponse<super::ChangesResponse>> {
+    ) -> crate::Result<ChangesResponse<Mailbox<Get>>> {
         let mut request = self.build();
         request
             .changes_mailbox(since_state)
@@ -147,7 +147,7 @@ impl Client {
 }
 
 impl Request<'_> {
-    pub fn get_mailbox(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_mailbox(&mut self) -> &mut GetRequest<Mailbox<Set>> {
         self.add_method_call(
             Method::GetMailbox,
             Arguments::mailbox_get(self.params(Method::GetMailbox)),
@@ -167,16 +167,11 @@ impl Request<'_> {
         .changes_mut()
     }
 
-    pub async fn send_changes_mailbox(
+    pub async fn send_changes_mailbox(self) -> crate::Result<ChangesResponse<Mailbox<Get>>> {
-        self,
-    ) -> crate::Result<ChangesResponse<super::ChangesResponse>> {
         self.send_single().await
     }
 
-    pub fn query_mailbox(
+    pub fn query_mailbox(&mut self) -> &mut QueryRequest<Mailbox<Set>> {
-        &mut self,
-    ) -> &mut QueryRequest<super::query::Filter, super::query::Comparator, super::QueryArguments>
-    {
         self.add_method_call(
             Method::QueryMailbox,
             Arguments::mailbox_query(self.params(Method::QueryMailbox)),
@@ -191,11 +186,7 @@ impl Request<'_> {
     pub fn query_mailbox_changes(
         &mut self,
         since_query_state: impl Into<String>,
-    ) -> &mut QueryChangesRequest<
+    ) -> &mut QueryChangesRequest<Mailbox<Set>> {
-        super::query::Filter,
-        super::query::Comparator,
-        super::QueryArguments,
-    > {
         self.add_method_call(
             Method::QueryChangesMailbox,
             Arguments::mailbox_query_changes(
@@ -210,7 +201,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_mailbox(&mut self) -> &mut SetRequest<Mailbox<Set>, super::SetArguments> {
+    pub fn set_mailbox(&mut self) -> &mut SetRequest<Mailbox<Set>> {
         self.add_method_call(
             Method::SetMailbox,
             Arguments::mailbox_set(self.params(Method::SetMailbox)),

src/mailbox/mod.rs

@@ -5,7 +5,9 @@ pub mod set;
 
 use std::fmt::Display;
 
-use crate::core::{set::string_not_set, Type};
+use crate::core::changes::ChangesObject;
+use crate::core::set::string_not_set;
+use crate::core::Object;
 use crate::mailbox::set::role_not_set;
 use crate::{Get, Set};
 use serde::{Deserialize, Serialize};
@@ -184,14 +186,26 @@ impl ChangesResponse {
     }
 }
 
-impl Type for Mailbox<Set> {
+impl Object for Mailbox<Set> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
 
-impl Type for Property {
+impl Object for Mailbox<Get> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
+
+impl ChangesObject for Mailbox<Set> {
+    type ChangesResponse = ChangesResponse;
+}
+
+impl ChangesObject for Mailbox<Get> {
+    type ChangesResponse = ChangesResponse;
+}

src/mailbox/query.rs

@@ -1,8 +1,11 @@
 use serde::Serialize;
 
-use crate::core::query::{self};
+use crate::{
+    core::query::{self, QueryObject},
+    Set,
+};
 
-use super::{QueryArguments, Role};
+use super::{Mailbox, QueryArguments, Role};
 
 #[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
@@ -97,3 +100,11 @@ impl QueryArguments {
         self
     }
 }
+
+impl QueryObject for Mailbox<Set> {
+    type QueryArguments = QueryArguments;
+
+    type Filter = Filter;
+
+    type Sort = Comparator;
+}

src/mailbox/set.rs

@@ -1,4 +1,4 @@
-use crate::{core::set::Create, Set};
+use crate::{core::set::SetObject, Get, Set};
 
 use super::{Mailbox, Role, SetArguments};
 
@@ -37,7 +37,9 @@ pub fn role_not_set(role: &Option<Role>) -> bool {
     matches!(role, Some(Role::None))
 }
 
-impl Create for Mailbox<Set> {
+impl SetObject for Mailbox<Set> {
+    type SetArguments = SetArguments;
+
     fn new(_create_id: Option<usize>) -> Self {
         Mailbox {
             _create_id,
@@ -61,6 +63,18 @@ impl Create for Mailbox<Set> {
     }
 }
 
+impl SetObject for Mailbox<Get> {
+    type SetArguments = SetArguments;
+
+    fn new(_create_id: Option<usize>) -> Self {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}
+
 impl SetArguments {
     pub fn on_destroy_remove_emails(&mut self, value: bool) -> &mut Self {
         self.on_destroy_remove_emails = value.into();

src/push_subscription/get.rs

@@ -1,4 +1,4 @@
-use crate::{Get, TypeState};
+use crate::{core::get::GetObject, Get, TypeState, Set};
 
 use super::{Keys, PushSubscription};
 
@@ -45,3 +45,11 @@ impl Keys {
         base64::decode_config(&self.auth, base64::URL_SAFE).ok()
     }
 }
+
+impl GetObject for PushSubscription<Set> {
+    type GetArguments = ();
+}
+
+impl GetObject for PushSubscription<Get> {
+    type GetArguments = ();
+}

src/push_subscription/helpers.rs

@@ -4,7 +4,7 @@ use crate::{
         get::GetRequest,
         request::{Arguments, Request},
         response::{PushSubscriptionGetResponse, PushSubscriptionSetResponse},
-        set::{Create, SetRequest},
+        set::{SetObject, SetRequest},
     },
     Method, Set, TypeState,
 };
@@ -76,7 +76,7 @@ impl Client {
 }
 
 impl Request<'_> {
-    pub fn get_push_subscription(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_push_subscription(&mut self) -> &mut GetRequest<PushSubscription<Set>> {
         self.add_method_call(
             Method::GetPushSubscription,
             Arguments::push_get(self.params(Method::GetPushSubscription)),
@@ -88,7 +88,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_push_subscription(&mut self) -> &mut SetRequest<PushSubscription<Set>, ()> {
+    pub fn set_push_subscription(&mut self) -> &mut SetRequest<PushSubscription<Set>> {
         self.add_method_call(
             Method::SetPushSubscription,
             Arguments::push_set(self.params(Method::SetPushSubscription)),

src/push_subscription/mod.rs

@@ -7,8 +7,9 @@ use std::fmt::Display;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
+use crate::core::changes::ChangesObject;
 use crate::core::set::list_not_set;
-use crate::core::Type;
+use crate::core::Object;
 use crate::{Get, Set, TypeState};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -86,14 +87,26 @@ pub struct Keys {
     auth: String,
 }
 
-impl Type for PushSubscription<Set> {
+impl Object for PushSubscription<Set> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         false
     }
 }
 
-impl Type for Property {
+impl Object for PushSubscription<Get> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         false
     }
 }
+
+impl ChangesObject for PushSubscription<Set> {
+    type ChangesResponse = ();
+}
+
+impl ChangesObject for PushSubscription<Get> {
+    type ChangesResponse = ();
+}

src/push_subscription/set.rs

@@ -1,6 +1,7 @@
 use crate::{
-    core::set::{from_timestamp, Create},
+    core::set::{from_timestamp, SetObject},
-    Set, TypeState,
+    email_submission::SetArguments,
+    Get, Set, TypeState,
 };
 
 use super::{Keys, PushSubscription};
@@ -37,7 +38,9 @@ impl PushSubscription<Set> {
     }
 }
 
-impl Create for PushSubscription<Set> {
+impl SetObject for PushSubscription<Set> {
+    type SetArguments = SetArguments;
+
     fn new(_create_id: Option<usize>) -> Self {
         PushSubscription {
             _create_id,
@@ -57,6 +60,18 @@ impl Create for PushSubscription<Set> {
     }
 }
 
+impl SetObject for PushSubscription<Get> {
+    type SetArguments = SetArguments;
+
+    fn new(_create_id: Option<usize>) -> Self {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}
+
 impl Keys {
     pub fn new(p256dh: &[u8], auth: &[u8]) -> Self {
         Keys {

src/thread/helpers.rs

@@ -2,7 +2,7 @@ use crate::{
     client::Client,
     core::{
         changes::{ChangesRequest, ChangesResponse},
-        get::GetRequest,
+        get::{GetObject, GetRequest},
         request::{Arguments, Request},
         response::ThreadGetResponse,
     },
@@ -23,7 +23,7 @@ impl Client {
 }
 
 impl Request<'_> {
-    pub fn get_thread(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_thread(&mut self) -> &mut GetRequest<Thread> {
         self.add_method_call(
             Method::GetThread,
             Arguments::thread_get(self.params(Method::GetThread)),
@@ -43,7 +43,11 @@ impl Request<'_> {
         .changes_mut()
     }
 
-    pub async fn send_changes_thread(self) -> crate::Result<ChangesResponse<()>> {
+    pub async fn send_changes_thread(self) -> crate::Result<ChangesResponse<Thread>> {
         self.send_single().await
     }
 }
+
+impl GetObject for Thread {
+    type GetArguments = ();
+}

src/thread/mod.rs

@@ -5,7 +5,7 @@ use std::fmt::Display;
 
 use serde::{Deserialize, Serialize};
 
-use crate::core::Type;
+use crate::core::{Object, changes::ChangesObject};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Thread {
@@ -22,7 +22,9 @@ pub enum Property {
     EmailIds,
 }
 
-impl Type for Property {
+impl Object for Thread {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
@@ -36,3 +38,8 @@ impl Display for Property {
         }
     }
 }
+
+impl ChangesObject for Thread {
+    type ChangesResponse = ();
+}
+

src/vacation_response/get.rs

@@ -1,4 +1,4 @@
-use crate::Get;
+use crate::{core::get::GetObject, Get, Set};
 
 use super::VacationResponse;
 
@@ -31,3 +31,11 @@ impl VacationResponse<Get> {
         self.html_body.as_deref()
     }
 }
+
+impl GetObject for VacationResponse<Set> {
+    type GetArguments = ();
+}
+
+impl GetObject for VacationResponse<Get> {
+    type GetArguments = ();
+}

src/vacation_response/helpers.rs

@@ -11,7 +11,7 @@ use crate::{
 use super::VacationResponse;
 
 impl Request<'_> {
-    pub fn get_vacation_response(&mut self) -> &mut GetRequest<super::Property, ()> {
+    pub fn get_vacation_response(&mut self) -> &mut GetRequest<VacationResponse<Set>> {
         self.add_capability(URI::VacationResponse);
         self.add_method_call(
             Method::GetVacationResponse,
@@ -24,7 +24,7 @@ impl Request<'_> {
         self.send_single().await
     }
 
-    pub fn set_vacation_response(&mut self) -> &mut SetRequest<VacationResponse<Set>, ()> {
+    pub fn set_vacation_response(&mut self) -> &mut SetRequest<VacationResponse<Set>> {
         self.add_capability(URI::VacationResponse);
         self.add_method_call(
             Method::SetVacationResponse,

src/vacation_response/mod.rs

@@ -4,9 +4,10 @@ pub mod set;
 
 use std::fmt::Display;
 
+use crate::core::changes::ChangesObject;
 use crate::core::set::date_not_set;
 use crate::core::set::string_not_set;
-use crate::core::Type;
+use crate::core::Object;
 use crate::Get;
 use crate::Set;
 use chrono::{DateTime, Utc};
@@ -81,14 +82,26 @@ impl Display for Property {
     }
 }
 
-impl Type for VacationResponse<Set> {
+impl Object for VacationResponse<Set> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
 
-impl Type for Property {
+impl Object for VacationResponse<Get> {
+    type Property = Property;
+
     fn requires_account_id() -> bool {
         true
     }
 }
+
+impl ChangesObject for VacationResponse<Set> {
+    type ChangesResponse = ();
+}
+
+impl ChangesObject for VacationResponse<Get> {
+    type ChangesResponse = ();
+}

src/vacation_response/set.rs

@@ -1,6 +1,7 @@
 use crate::{
-    core::set::{from_timestamp, Create},
+    core::set::{from_timestamp, SetObject},
-    Set,
+    email_submission::SetArguments,
+    Get, Set,
 };
 
 use super::VacationResponse;
@@ -37,7 +38,9 @@ impl VacationResponse<Set> {
     }
 }
 
-impl Create for VacationResponse<Set> {
+impl SetObject for VacationResponse<Set> {
+    type SetArguments = SetArguments;
+
     fn new(_create_id: Option<usize>) -> Self {
         VacationResponse {
             _create_id,
@@ -56,3 +59,15 @@ impl Create for VacationResponse<Set> {
         self._create_id.map(|id| format!("c{}", id))
     }
 }
+
+impl SetObject for VacationResponse<Get> {
+    type SetArguments = SetArguments;
+
+    fn new(_create_id: Option<usize>) -> Self {
+        unimplemented!()
+    }
+
+    fn create_id(&self) -> Option<String> {
+        None
+    }
+}