diff --git a/conjure-codegen/src/aliases.rs b/conjure-codegen/src/aliases.rs
index 8b9b34c1..c1c75040 100644
--- a/conjure-codegen/src/aliases.rs
+++ b/conjure-codegen/src/aliases.rs
@@ -148,5 +148,12 @@ pub fn generate(ctx: &Context, def: &AliasDefinition) -> TokenStream {
                 &mut self.0
             }
         }
+
+        impl std::convert::AsRef<#dealiased_type> for #name {
+            #[inline]
+            fn as_ref(&self) -> &#dealiased_type {
+                &self.0
+            }
+        }
     }
 }
diff --git a/conjure-codegen/src/clients.rs b/conjure-codegen/src/clients.rs
index d393f3d5..0e4d9144 100644
--- a/conjure-codegen/src/clients.rs
+++ b/conjure-codegen/src/clients.rs
@@ -1,4 +1,4 @@
-// Copyright 2019 Palantir Technologies, Inc.
+// Copyright 2025 Palantir Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,14 +11,17 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-use crate::context::{BaseModule, Context};
-use crate::http_paths::{self, PathSegment};
-use crate::types::objects::{
-    ArgumentDefinition, AuthType, EndpointDefinition, ParameterType, ServiceDefinition, Type,
-};
+
 use proc_macro2::TokenStream;
 use quote::quote;
-use std::collections::HashMap;
+use syn::Ident;
+
+use crate::{
+    context::{BaseModule, Context},
+    types::objects::{
+        ArgumentDefinition, AuthType, EndpointDefinition, ParameterType, ServiceDefinition, Type,
+    },
+};
 
 #[derive(Copy, Clone)]
 enum Style {
@@ -27,489 +30,271 @@ enum Style {
 }
 
 pub fn generate(ctx: &Context, def: &ServiceDefinition) -> TokenStream {
-    let async_ = generate_inner(ctx, def, Style::Async);
-    let sync = generate_inner(ctx, def, Style::Sync);
+    let sync_trait = generate_trait(ctx, def, Style::Sync);
+    let async_trait = generate_trait(ctx, def, Style::Async);
 
     quote! {
-        #async_
+        use conjure_http::endpoint;
 
-        #sync
+        #sync_trait
+        #async_trait
     }
 }
 
-fn generate_inner(ctx: &Context, def: &ServiceDefinition, style: Style) -> TokenStream {
+fn generate_trait(ctx: &Context, def: &ServiceDefinition, style: Style) -> TokenStream {
     let docs = ctx.docs(def.docs());
-    let suffix = match style {
-        Style::Async => "AsyncClient",
-        Style::Sync => "Client",
-    };
-    let name = ctx.type_name(&format!("{}{}", def.service_name().name(), suffix));
-
-    let service = match style {
-        Style::Async => quote!(AsyncService),
-        Style::Sync => quote!(Service),
-    };
-
-    let client_bound = match style {
-        Style::Async => quote!(AsyncClient),
-        Style::Sync => quote!(Client),
+    let service_name = def.service_name().name();
+    let name = trait_name(ctx, def, style);
+    let version = match ctx.version() {
+        Some(version) => {
+            let some = ctx.some_ident(def.service_name());
+            quote!(, version = #some(#version))
+        }
+        None => quote!(),
     };
+    let params = params(ctx, def, style);
 
     let endpoints = def
         .endpoints()
         .iter()
-        .map(|e| generate_endpoint(ctx, def, style, e));
+        .map(|e| generate_trait_endpoint(ctx, def, e, style));
 
     quote! {
         #docs
-        #[derive(Clone, Debug)]
-        pub struct #name<T>(T);
+        #[conjure_http::conjure_client(name = #service_name #version)]
+        pub trait #name #params {
+            #(#endpoints)*
+        }
+    }
+}
 
-        impl<T> conjure_http::client::#service<T> for #name<T>
-        where
-            T: conjure_http::client::#client_bound,
-        {
-            fn new(client: T) -> Self {
-                #name(client)
+fn trait_name(ctx: &Context, def: &ServiceDefinition, style: Style) -> Ident {
+    match style {
+        Style::Async => ctx.type_name(&format!("Async{}", def.service_name().name())),
+        Style::Sync => ctx.type_name(def.service_name().name()),
+    }
+}
+
+fn params(ctx: &Context, def: &ServiceDefinition, style: Style) -> TokenStream {
+    let mut params = vec![];
+    if service_has_binary_request_body(ctx, def) {
+        params.push(quote! {
+            #[request_writer]
+            O
+        })
+    }
+
+    if !def.endpoints().is_empty() {
+        let result = ctx.result_ident(def.service_name());
+        let trait_ = match style {
+            Style::Async => quote!(conjure_http::private::Stream),
+            Style::Sync => {
+                let iterator = ctx.iterator_ident(def.service_name());
+                quote!(#iterator)
             }
-        }
+        };
+        params.push(quote! {
+            #[response_body]
+            I: #trait_<Item = #result<conjure_http::private::Bytes, conjure_http::private::Error>>
+        });
+    }
 
-        impl<T> #name<T>
-        where
-            T: conjure_http::client::#client_bound,
-        {
-            #(#endpoints)*
-        }
+    if params.is_empty() {
+        quote!()
+    } else {
+        quote!(<#(#params),*>)
     }
 }
 
-fn generate_endpoint(
+fn service_has_binary_request_body(ctx: &Context, def: &ServiceDefinition) -> bool {
+    def.endpoints()
+        .iter()
+        .any(|e| endpoint_has_binary_request_body(ctx, e))
+}
+
+fn endpoint_has_binary_request_body(ctx: &Context, endpoint: &EndpointDefinition) -> bool {
+    endpoint.args().iter().any(|a| match a.param_type() {
+        ParameterType::Body(_) => ctx.is_binary(a.type_()),
+        _ => false,
+    })
+}
+
+fn generate_trait_endpoint(
     ctx: &Context,
     def: &ServiceDefinition,
-    style: Style,
     endpoint: &EndpointDefinition,
+    style: Style,
 ) -> TokenStream {
     let docs = ctx.docs(endpoint.docs());
-    let deprecated = match endpoint.deprecated() {
-        Some(docs) => {
-            let docs = &**docs;
-            quote! {
-                #[deprecated(note = #docs)]
-            }
-        }
-        None => quote!(),
-    };
-
+    let method = endpoint
+        .http_method()
+        .as_str()
+        .parse::<TokenStream>()
+        .unwrap();
+    let path = path(endpoint);
+    let endpoint_name = &**endpoint.endpoint_name();
     let async_ = match style {
         Style::Async => quote!(async),
         Style::Sync => quote!(),
     };
-
     let name = ctx.field_name(endpoint.endpoint_name());
+    let accept = accept(ctx, endpoint);
 
-    let body_arg = body_arg(endpoint);
-    let params = params(ctx, body_arg);
-
-    let auth = quote!(auth_);
-    let auth_arg = auth_arg(endpoint, &auth);
-    let args = endpoint.args().iter().map(|a| {
-        let name = ctx.field_name(a.arg_name());
-        let ty = arg_type(ctx, def, a);
-        quote!(#name: #ty)
-    });
+    let auth_arg = auth_arg(endpoint);
+    let args = endpoint.args().iter().map(|a| arg(ctx, def, a, style));
 
     let result = ctx.result_ident(def.service_name());
-    let ret = return_type(ctx, endpoint);
-    let ret_name = return_type_name(ctx, def, &ret);
-    let where_ = where_(ctx, style, body_arg);
-
-    let request = quote!(request_);
-    let setup_request = setup_request(ctx, body_arg, style, &request);
-
-    let method = endpoint
-        .http_method()
-        .as_str()
-        .parse::<TokenStream>()
-        .unwrap();
-
-    let setup_path = setup_path(ctx, endpoint, &request);
-
-    let setup_headers = setup_headers(ctx, endpoint, &request, &auth);
 
-    let setup_response_headers = setup_response_headers(&ret, &request);
-
-    let setup_endpoint_extension = setup_endpoint_extension(ctx, def, endpoint, &request);
-
-    let await_ = match style {
-        Style::Async => quote!(.await),
-        Style::Sync => quote!(),
-    };
-
-    let response = quote!(response_);
-    let decode_response = setup_decode_response(ctx, &ret, style, &response);
+    let ret_ty = rust_return_type(ctx, def, endpoint);
+    let ret_ty = quote!(#result<#ret_ty, conjure_http::private::Error>);
 
     quote! {
         #docs
-        #deprecated
-        pub #async_ fn #name #params(&self #auth_arg #(, #args)*) -> #result<#ret_name, conjure_http::private::Error>
-        #where_
-        {
-            #setup_request
-            *#request.method_mut() = conjure_http::private::http::Method::#method;
-            #setup_path
-            #setup_headers
-            #setup_response_headers
-            #setup_endpoint_extension
-
-            let #response = self.0.send(#request)#await_?;
-            #decode_response
-        }
+        #[endpoint(method = #method, path = #path, name = #endpoint_name, accept = #accept)]
+        #async_ fn #name(&self #auth_arg #(, #args)*) -> #ret_ty;
     }
 }
 
-fn body_arg(endpoint: &EndpointDefinition) -> Option<&ArgumentDefinition> {
+/// We need to strip the legacy regexes off of path params:
+///
+/// /foo/{bar:.*} -> /foo/{bar}
+fn path(endpoint: &EndpointDefinition) -> String {
     endpoint
-        .args()
-        .iter()
-        .find(|a| matches!(a.param_type(), ParameterType::Body(_)))
+        .http_path()
+        .split('/')
+        .map(
+            |segment| match segment.strip_prefix('{').and_then(|s| s.strip_suffix('}')) {
+                Some(segment) => format!("{{{}}}", segment.split(':').next().unwrap()),
+                None => segment.to_string(),
+            },
+        )
+        .collect::<Vec<_>>()
+        .join("/")
 }
 
-fn params(ctx: &Context, body_arg: Option<&ArgumentDefinition>) -> TokenStream {
-    match body_arg {
-        Some(a) if ctx.is_binary(a.type_()) => quote!(<U>),
-        _ => quote!(),
+fn accept(ctx: &Context, endpoint: &EndpointDefinition) -> TokenStream {
+    match return_type(ctx, endpoint) {
+        ReturnType::None => quote!(conjure_http::client::conjure::EmptyResponseDeserializer),
+        ReturnType::Json(ty) => {
+            if ctx.is_iterable(ty) {
+                quote!(conjure_http::client::conjure::CollectionResponseDeserializer)
+            } else {
+                quote!(conjure_http::client::StdResponseDeserializer)
+            }
+        }
+        ReturnType::Binary => quote!(conjure_http::client::conjure::BinaryResponseDeserializer),
+        ReturnType::OptionalBinary => {
+            quote!(conjure_http::client::conjure::OptionalBinaryResponseDeserializer)
+        }
     }
 }
 
-fn where_(ctx: &Context, style: Style, body_arg: Option<&ArgumentDefinition>) -> TokenStream {
-    match body_arg {
-        Some(a) if ctx.is_binary(a.type_()) => {
-            let bound = match style {
-                Style::Async => {
-                    quote!(conjure_http::client::AsyncWriteBody<T::BodyWriter> + Sync + Send)
+fn auth_arg(endpoint: &EndpointDefinition) -> TokenStream {
+    match endpoint.auth() {
+        Some(auth) => {
+            let params = match auth {
+                AuthType::Header(_) => quote!(),
+                AuthType::Cookie(cookie) => {
+                    let name = &cookie.cookie_name();
+                    quote!((cookie_name = #name))
                 }
-                Style::Sync => quote!(conjure_http::client::WriteBody<T::BodyWriter>),
             };
-            quote!(where U: #bound,)
+            quote!(, #[auth #params] auth_: &conjure_object::BearerToken)
         }
-        _ => quote!(),
-    }
-}
-
-fn auth_arg(endpoint: &EndpointDefinition, auth: &TokenStream) -> TokenStream {
-    match endpoint.auth() {
-        Some(_) => quote!(, #auth: &conjure_object::BearerToken),
         None => quote!(),
     }
 }
 
-fn arg_type(ctx: &Context, def: &ServiceDefinition, arg: &ArgumentDefinition) -> TokenStream {
-    if ctx.is_binary(arg.type_()) {
-        quote!(U)
-    } else {
-        ctx.borrowed_rust_type(BaseModule::Clients, def.service_name(), arg.type_())
-    }
-}
-
-fn return_type<'a>(ctx: &Context, endpoint: &'a EndpointDefinition) -> ReturnType<'a> {
-    match endpoint.returns() {
-        Some(ret) => match ctx.is_optional(ret) {
-            Some(inner) if ctx.is_binary(inner) => ReturnType::OptionalBinary,
-            _ if ctx.is_binary(ret) => ReturnType::Binary,
-            _ => ReturnType::Json(ret),
-        },
-        None => ReturnType::None,
-    }
-}
-
-fn return_type_name(ctx: &Context, def: &ServiceDefinition, ty: &ReturnType<'_>) -> TokenStream {
-    match ty {
-        ReturnType::None => quote!(()),
-        ReturnType::Json(ty) => ctx.rust_type(BaseModule::Clients, def.service_name(), ty),
-        ReturnType::Binary => quote!(T::ResponseBody),
-        ReturnType::OptionalBinary => {
-            let option = ctx.option_ident(def.service_name());
-            quote!(#option<T::ResponseBody>)
-        }
-    }
-}
-
-fn setup_request(
+fn arg(
     ctx: &Context,
-    body_arg: Option<&ArgumentDefinition>,
+    def: &ServiceDefinition,
+    arg: &ArgumentDefinition,
     style: Style,
-    request: &TokenStream,
 ) -> TokenStream {
-    match body_arg {
-        Some(body_arg) => {
-            let name = ctx.field_name(body_arg.arg_name());
-            if ctx.is_binary(body_arg.type_()) {
-                match style {
-                    Style::Sync => quote! {
-                        let mut #request = conjure_http::private::encode_binary_request(#name);
-                    },
-                    Style::Async => quote! {
-                        let mut #request = conjure_http::private::async_encode_binary_request(#name);
-                    },
-                }
+    let name = ctx.field_name(arg.arg_name());
+
+    let attr = match arg.param_type() {
+        ParameterType::Body(_) => {
+            let serializer = if ctx.is_binary(arg.type_()) {
+                quote!(conjure_http::client::conjure::BinaryRequestSerializer)
             } else {
-                let function = match style {
-                    Style::Sync => quote!(encode_serializable_request),
-                    Style::Async => quote!(async_encode_serializable_request),
-                };
-                quote! {
-                    let mut #request = conjure_http::private::#function(&#name);
-                }
-            }
+                quote!(conjure_http::client::StdRequestSerializer)
+            };
+            quote!(#[body(serializer = #serializer)])
         }
-        None => {
-            let function = match style {
-                Style::Sync => quote!(encode_empty_request),
-                Style::Async => quote!(async_encode_empty_request),
+        ParameterType::Header(header) => {
+            let name = &**header.param_id();
+            let mut encoder = if ctx.is_optional(arg.type_()).is_some() {
+                quote!(conjure_http::client::conjure::PlainSeqEncoder)
+            } else {
+                quote!(conjure_http::client::conjure::PlainEncoder)
             };
-            quote! {
-                let mut #request = conjure_http::private::#function();
+            let dealiased = ctx.dealiased_type(arg.type_());
+            if dealiased != arg.type_() {
+                let dealiased = ctx.rust_type(BaseModule::Clients, def.service_name(), dealiased);
+                encoder = quote!(conjure_http::client::AsRefEncoder<#encoder, #dealiased>)
             }
+            quote!(#[header(name = #name, encoder = #encoder)])
         }
-    }
-}
-
-fn setup_path(ctx: &Context, endpoint: &EndpointDefinition, request: &TokenStream) -> TokenStream {
-    let path = quote!(path_);
-    let path_components = setup_path_components(ctx, endpoint, &path);
-    let query_components = setup_query_components(ctx, endpoint, &path);
-
-    quote! {
-        let mut #path = conjure_http::private::UriBuilder::new();
-        #path_components
-        #query_components
-        *#request.uri_mut() = #path.build();
-    }
-}
-
-fn setup_path_components(
-    ctx: &Context,
-    endpoint: &EndpointDefinition,
-    path: &TokenStream,
-) -> TokenStream {
-    let path_params = endpoint
-        .args()
-        .iter()
-        .filter(|arg| matches!(arg.param_type(), &ParameterType::Path(_)))
-        .map(|arg| {
-            let key = &***arg.arg_name();
-            let value = ctx.field_name(key);
-            (key, value)
-        })
-        .collect::<HashMap<_, _>>();
-
-    let mut calls = vec![];
-    let mut cur = String::new();
-    for segment in http_paths::parse(endpoint.http_path()) {
-        match segment {
-            PathSegment::Literal(lit) => {
-                cur.push('/');
-                cur.push_str(lit);
-            }
-            PathSegment::Parameter { name, .. } => {
-                if !cur.is_empty() {
-                    calls.push(quote!(#path.push_literal(#cur);));
-                    cur.clear();
-                }
-                let arg = &path_params[name];
-                calls.push(quote!(#path.push_path_parameter(&#arg);));
-            }
+        ParameterType::Path(_) => {
+            let name = &**arg.arg_name();
+            quote!(#[path(name = #name, encoder = conjure_http::client::conjure::PlainEncoder)])
         }
-    }
-
-    if !cur.is_empty() {
-        calls.push(quote!(#path.push_literal(#cur);));
-    }
-
-    quote!(#(#calls)*)
-}
-
-fn setup_query_components(
-    ctx: &Context,
-    endpoint: &EndpointDefinition,
-    path: &TokenStream,
-) -> TokenStream {
-    let mut calls = vec![];
-
-    for argument in endpoint.args() {
-        let query = match argument.param_type() {
-            ParameterType::Query(query) => query,
-            _ => continue,
-        };
-
-        let key = &**query.param_id();
-        let name = ctx.field_name(argument.arg_name());
-
-        let call = if ctx.is_optional(argument.type_()).is_some() {
-            quote! {
-                #path.push_optional_query_parameter(#key, &#name);
-            }
-        } else if ctx.is_list(argument.type_()) {
-            quote! {
-                #path.push_list_query_parameter(#key, &#name);
-            }
-        } else if ctx.is_set(argument.type_()) {
-            quote! {
-                #path.push_set_query_parameter(#key, &#name);
-            }
-        } else {
-            quote! {
-                #path.push_query_parameter(#key, &#name);
-            }
-        };
-        calls.push(call);
-    }
-
-    quote!(#(#calls)*)
-}
-
-fn setup_headers(
-    ctx: &Context,
-    endpoint: &EndpointDefinition,
-    request: &TokenStream,
-    auth: &TokenStream,
-) -> TokenStream {
-    let mut calls = vec![];
-
-    if let Some(call) = auth_header(endpoint, request, auth) {
-        calls.push(call);
-    }
-
-    for argument in endpoint.args() {
-        let header = match argument.param_type() {
-            ParameterType::Header(header) => header,
-            _ => continue,
-        };
-
-        // HeaderName::from_static expects http2-style lowercased headers
-        let header = header.param_id().to_lowercase();
-        let name = ctx.field_name(argument.arg_name());
-
-        let call = if ctx.is_optional(argument.type_()).is_some() {
-            quote! {
-                conjure_http::private::encode_optional_header(&mut #request, #header, &#name)?;
-            }
-        } else {
-            quote! {
-                conjure_http::private::encode_header(&mut #request, #header, &#name)?;
+        ParameterType::Query(query) => {
+            let name = &**query.param_id();
+            let mut encoder = if ctx.is_iterable(arg.type_()) {
+                quote!(conjure_http::client::conjure::PlainSeqEncoder)
+            } else {
+                quote!(conjure_http::client::conjure::PlainEncoder)
+            };
+            let dealiased = ctx.dealiased_type(arg.type_());
+            if dealiased != arg.type_() {
+                let dealiased = ctx.rust_type(BaseModule::Clients, def.service_name(), dealiased);
+                encoder = quote!(conjure_http::client::AsRefEncoder<#encoder, #dealiased>)
             }
-        };
-
-        calls.push(call);
-    }
-
-    quote!(#(#calls)*)
-}
-
-fn auth_header(
-    endpoint: &EndpointDefinition,
-    request: &TokenStream,
-    auth: &TokenStream,
-) -> Option<TokenStream> {
-    match endpoint.auth() {
-        Some(AuthType::Cookie(cookie)) => {
-            let prefix = format!("{}=", cookie.cookie_name());
-            Some(quote! {
-                conjure_http::private::encode_cookie_auth(&mut #request, #prefix, #auth);
-            })
+            quote!(#[query(name = #name, encoder = #encoder)])
         }
-        Some(AuthType::Header(_)) => Some(quote! {
-            conjure_http::private::encode_header_auth(&mut #request, #auth);
-        }),
-        None => None,
-    }
-}
+    };
 
-fn setup_response_headers(ty: &ReturnType<'_>, request: &TokenStream) -> TokenStream {
-    match ty {
-        ReturnType::None => quote! {
-            conjure_http::private::encode_empty_response_headers(&mut #request);
-        },
-        ReturnType::Json(_) => {
-            quote! {
-                conjure_http::private::encode_serializable_response_headers(&mut #request);
+    let ty = if ctx.is_binary(arg.type_()) {
+        match style {
+            Style::Async => {
+                let sync = ctx.sync_ident(def.service_name());
+                let send = ctx.send_ident(def.service_name());
+                quote!(impl conjure_http::client::AsyncWriteBody<O> + #sync + #send)
             }
+            Style::Sync => quote!(impl conjure_http::client::WriteBody<O>),
         }
-        ReturnType::Binary | &ReturnType::OptionalBinary => quote! {
-            conjure_http::private::encode_binary_response_headers(&mut #request);
-        },
-    }
+    } else {
+        ctx.borrowed_rust_type(BaseModule::Clients, def.service_name(), arg.type_())
+    };
+    quote!(#attr #name: #ty)
 }
 
-fn setup_endpoint_extension(
+fn rust_return_type(
     ctx: &Context,
-    service: &ServiceDefinition,
+    def: &ServiceDefinition,
     endpoint: &EndpointDefinition,
-    request: &TokenStream,
 ) -> TokenStream {
-    let service = service.service_name().name();
-    let version = match ctx.version() {
-        Some(version) => quote! {
-            conjure_http::private::Option::Some(#version)
-        },
-        None => quote! {
-            conjure_http::private::Option::None
-        },
-    };
-    let name = &***endpoint.endpoint_name();
-    let path = &***endpoint.http_path();
-
-    quote! {
-        #request.extensions_mut().insert(conjure_http::client::Endpoint::new(
-            #service,
-            #version,
-            #name,
-            #path,
-        ));
+    match return_type(ctx, endpoint) {
+        ReturnType::None => quote!(()),
+        ReturnType::Json(ty) => ctx.rust_type(BaseModule::Clients, def.service_name(), ty),
+        ReturnType::Binary => quote!(I),
+        ReturnType::OptionalBinary => {
+            let option = ctx.option_ident(def.service_name());
+            quote!(#option<I>)
+        }
     }
 }
 
-fn setup_decode_response(
-    ctx: &Context,
-    ty: &ReturnType<'_>,
-    style: Style,
-    response: &TokenStream,
-) -> TokenStream {
-    match (ty, style) {
-        (ReturnType::None, Style::Sync) => quote! {
-            conjure_http::private::decode_empty_response(#response)
-        },
-        (ReturnType::None, Style::Async) => quote! {
-            conjure_http::private::async_decode_empty_response(#response).await
-        },
-        (ReturnType::Json(ty), Style::Sync) => {
-            if ctx.is_iterable(ty) {
-                quote! {
-                    conjure_http::private::decode_default_serializable_response(#response)
-                }
-            } else {
-                quote! {
-                    conjure_http::private::decode_serializable_response(#response)
-                }
-            }
-        }
-        (ReturnType::Json(ty), Style::Async) => {
-            if ctx.is_iterable(ty) {
-                quote! {
-                    conjure_http::private::async_decode_default_serializable_response(#response).await
-                }
-            } else {
-                quote! {
-                    conjure_http::private::async_decode_serializable_response(#response).await
-                }
-            }
-        }
-        (ReturnType::Binary, _) => quote! {
-            conjure_http::private::decode_binary_response(#response)
-        },
-        (ReturnType::OptionalBinary, _) => quote! {
-            conjure_http::private::decode_optional_binary_response(#response)
+fn return_type<'a>(ctx: &Context, endpoint: &'a EndpointDefinition) -> ReturnType<'a> {
+    match endpoint.returns() {
+        Some(ty) => match ctx.is_optional(ty) {
+            Some(inner) if ctx.is_binary(inner) => ReturnType::OptionalBinary,
+            _ if ctx.is_binary(ty) => ReturnType::Binary,
+            _ => ReturnType::Json(ty),
         },
+        None => ReturnType::None,
     }
 }
 
diff --git a/conjure-codegen/src/context.rs b/conjure-codegen/src/context.rs
index afd4a828..dcd7aa35 100644
--- a/conjure-codegen/src/context.rs
+++ b/conjure-codegen/src/context.rs
@@ -794,42 +794,6 @@ impl Context {
         }
     }
 
-    pub fn is_list(&self, def: &Type) -> bool {
-        match def {
-            Type::List(_) => true,
-            Type::Primitive(_) | Type::Optional(_) | Type::Set(_) | Type::Map(_) => false,
-            Type::Reference(def) => self.is_list_ref(def),
-            Type::External(def) => self.is_list(def.fallback()),
-        }
-    }
-
-    fn is_list_ref(&self, name: &TypeName) -> bool {
-        let ctx = &self.types[name];
-
-        match &ctx.def {
-            TypeDefinition::Alias(def) => self.is_list(def.alias()),
-            TypeDefinition::Enum(_) | TypeDefinition::Object(_) | TypeDefinition::Union(_) => false,
-        }
-    }
-
-    pub fn is_set(&self, def: &Type) -> bool {
-        match def {
-            Type::Set(_) => true,
-            Type::Primitive(_) | Type::Optional(_) | Type::List(_) | Type::Map(_) => false,
-            Type::Reference(def) => self.is_set_ref(def),
-            Type::External(def) => self.is_set(def.fallback()),
-        }
-    }
-
-    fn is_set_ref(&self, name: &TypeName) -> bool {
-        let ctx = &self.types[name];
-
-        match &ctx.def {
-            TypeDefinition::Alias(def) => self.is_set(def.alias()),
-            TypeDefinition::Enum(_) | TypeDefinition::Object(_) | TypeDefinition::Union(_) => false,
-        }
-    }
-
     #[allow(clippy::only_used_in_recursion)]
     pub fn is_double(&self, def: &Type) -> bool {
         match def {
@@ -915,6 +879,14 @@ impl Context {
         self.prelude_ident(name, "IntoIterator", "std::iter::IntoIterator")
     }
 
+    pub fn iterator_ident(&self, name: &TypeName) -> TokenStream {
+        self.prelude_ident(name, "Iterator", "std::iter::Iterator")
+    }
+
+    pub fn sync_ident(&self, name: &TypeName) -> TokenStream {
+        self.prelude_ident(name, "Sync", "std::marker::Sync")
+    }
+
     pub fn send_ident(&self, name: &TypeName) -> TokenStream {
         self.prelude_ident(name, "Send", "std::marker::Send")
     }
diff --git a/conjure-codegen/src/example_types/clients/another/mod.rs b/conjure-codegen/src/example_types/clients/another/mod.rs
index d75c5d60..e42b98f1 100644
--- a/conjure-codegen/src/example_types/clients/another/mod.rs
+++ b/conjure-codegen/src/example_types/clients/another/mod.rs
@@ -1,3 +1,5 @@
 #[doc(inline)]
-pub use self::test_service::{TestServiceClient, TestServiceAsyncClient};
+pub use self::test_service::{
+    TestService, TestServiceClient, AsyncTestService, AsyncTestServiceClient,
+};
 pub mod test_service;
diff --git a/conjure-codegen/src/example_types/clients/another/test_service.rs b/conjure-codegen/src/example_types/clients/another/test_service.rs
index ac8c0d40..876f6832 100644
--- a/conjure-codegen/src/example_types/clients/another/test_service.rs
+++ b/conjure-codegen/src/example_types/clients/another/test_service.rs
@@ -1,21 +1,24 @@
+use conjure_http::endpoint;
 ///A Markdown description of the service.
-#[derive(Clone, Debug)]
-pub struct TestServiceAsyncClient<T>(T);
-impl<T> conjure_http::client::AsyncService<T> for TestServiceAsyncClient<T>
-where
-    T: conjure_http::client::AsyncClient,
-{
-    fn new(client: T) -> Self {
-        TestServiceAsyncClient(client)
-    }
-}
-impl<T> TestServiceAsyncClient<T>
-where
-    T: conjure_http::client::AsyncClient,
-{
+#[conjure_http::conjure_client(name = "TestService")]
+pub trait TestService<
+    #[request_writer]
+    O,
+    #[response_body]
+    I: Iterator<
+            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
+        >,
+> {
     ///Returns a mapping from file system id to backing file system configuration.
-    pub async fn get_file_systems(
+    #[endpoint(
+        method = GET,
+        path = "/catalog/fileSystems",
+        name = "getFileSystems",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn get_file_systems(
         &self,
+        #[auth]
         auth_: &conjure_object::BearerToken,
     ) -> Result<
         std::collections::BTreeMap<
@@ -23,599 +26,371 @@ where
             super::super::super::objects::product::datasets::BackingFileSystem,
         >,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/fileSystems");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getFileSystems",
-                    "/catalog/fileSystems",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn create_dataset(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets",
+        name = "createDataset",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn create_dataset(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         request: &super::super::super::objects::product::CreateDatasetRequest,
+        #[header(
+            name = "Test-Header",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         test_header_arg: &str,
     ) -> Result<
         super::super::super::objects::product::datasets::Dataset,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::async_encode_serializable_request(
-            &request,
-        );
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_header(
-            &mut request_,
-            "test-header",
-            &test_header_arg,
-        )?;
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "createDataset",
-                    "/catalog/datasets",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn get_dataset(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}",
+        name = "getDataset",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn get_dataset(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
     ) -> Result<
         Option<super::super::super::objects::product::datasets::Dataset>,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getDataset",
-                    "/catalog/datasets/{datasetRid}",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn get_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw",
+        name = "getRawData",
+        accept = conjure_http::client::conjure::BinaryResponseDeserializer
+    )]
+    fn get_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<T::ResponseBody, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getRawData",
-                    "/catalog/datasets/{datasetRid}/raw",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::decode_binary_response(response_)
-    }
-    pub async fn get_aliased_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<I, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw-aliased",
+        name = "getAliasedRawData",
+        accept = conjure_http::client::conjure::BinaryResponseDeserializer
+    )]
+    fn get_aliased_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<T::ResponseBody, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getAliasedRawData",
-                    "/catalog/datasets/{datasetRid}/raw-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::decode_binary_response(response_)
-    }
-    pub async fn maybe_get_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<I, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw-maybe",
+        name = "maybeGetRawData",
+        accept = conjure_http::client::conjure::OptionalBinaryResponseDeserializer
+    )]
+    fn maybe_get_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<Option<T::ResponseBody>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw-maybe");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "maybeGetRawData",
-                    "/catalog/datasets/{datasetRid}/raw-maybe",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::decode_optional_binary_response(response_)
-    }
-    pub async fn get_aliased_string(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<I>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/string-aliased",
+        name = "getAliasedString",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn get_aliased_string(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
     ) -> Result<
         super::super::super::objects::product::AliasedString,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/string-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getAliasedString",
-                    "/catalog/datasets/{datasetRid}/string-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn upload_raw_data<U>(
-        &self,
-        auth_: &conjure_object::BearerToken,
-        input: U,
-    ) -> Result<(), conjure_http::private::Error>
-    where
-        U: conjure_http::client::AsyncWriteBody<T::BodyWriter> + Sync + Send,
-    {
-        let mut request_ = conjure_http::private::async_encode_binary_request(input);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets/upload-raw");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "uploadRawData",
-                    "/catalog/datasets/upload-raw",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_empty_response(response_).await
-    }
-    pub async fn upload_aliased_raw_data<U>(
-        &self,
-        auth_: &conjure_object::BearerToken,
-        input: U,
-    ) -> Result<(), conjure_http::private::Error>
-    where
-        U: conjure_http::client::AsyncWriteBody<T::BodyWriter> + Sync + Send,
-    {
-        let mut request_ = conjure_http::private::async_encode_binary_request(input);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets/upload-raw-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "uploadAliasedRawData",
-                    "/catalog/datasets/upload-raw-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_empty_response(response_).await
-    }
-    pub async fn get_branches(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets/upload-raw",
+        name = "uploadRawData",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    fn upload_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
+        input: impl conjure_http::client::WriteBody<O>,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets/upload-raw-aliased",
+        name = "uploadAliasedRawData",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    fn upload_aliased_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
+        input: impl conjure_http::client::WriteBody<O>,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branches",
+        name = "getBranches",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn get_branches(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branches");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getBranches",
-                    "/catalog/datasets/{datasetRid}/branches",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
+    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error>;
     ///Gets all branches of this dataset.
-    #[deprecated(note = "use getBranches instead")]
-    pub async fn get_branches_deprecated(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branchesDeprecated",
+        name = "getBranchesDeprecated",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn get_branches_deprecated(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branchesDeprecated");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getBranchesDeprecated",
-                    "/catalog/datasets/{datasetRid}/branchesDeprecated",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn resolve_branch(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branches/{branch}/resolve",
+        name = "resolveBranch",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn resolve_branch(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
+        #[path(name = "branch", encoder = conjure_http::client::conjure::PlainEncoder)]
         branch: &str,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branches");
-        path_.push_path_parameter(&branch);
-        path_.push_literal("/resolve");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "resolveBranch",
-                    "/catalog/datasets/{datasetRid}/branches/{branch:.+}/resolve",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn test_param(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/testParam",
+        name = "testParam",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn test_param(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/testParam");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testParam",
-                    "/catalog/datasets/{datasetRid}/testParam",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn test_query_params(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/test-query-params",
+        name = "testQueryParams",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn test_query_params(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         query: &str,
+        #[query(
+            name = "different",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         something: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "optionalMiddle",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_middle: Option<&conjure_object::ResourceIdentifier>,
+        #[query(
+            name = "implicit",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         implicit: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "setEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         set_end: &std::collections::BTreeSet<String>,
+        #[query(
+            name = "optionalEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_end: Option<&conjure_object::ResourceIdentifier>,
-    ) -> Result<i32, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_serializable_request(
-            &query,
-        );
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/test-query-params");
-        path_.push_query_parameter("different", &something);
-        path_.push_optional_query_parameter("optionalMiddle", &optional_middle);
-        path_.push_query_parameter("implicit", &implicit);
-        path_.push_set_query_parameter("setEnd", &set_end);
-        path_.push_optional_query_parameter("optionalEnd", &optional_end);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testQueryParams",
-                    "/catalog/test-query-params",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn test_no_response_query_params(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<i32, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/test-no-response-query-params",
+        name = "testNoResponseQueryParams",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    fn test_no_response_query_params(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         query: &str,
+        #[query(
+            name = "different",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         something: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "optionalMiddle",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_middle: Option<&conjure_object::ResourceIdentifier>,
+        #[query(
+            name = "implicit",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         implicit: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "setEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         set_end: &std::collections::BTreeSet<String>,
+        #[query(
+            name = "optionalEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_end: Option<&conjure_object::ResourceIdentifier>,
-    ) -> Result<(), conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_serializable_request(
-            &query,
-        );
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/test-no-response-query-params");
-        path_.push_query_parameter("different", &something);
-        path_.push_optional_query_parameter("optionalMiddle", &optional_middle);
-        path_.push_query_parameter("implicit", &implicit);
-        path_.push_set_query_parameter("setEnd", &set_end);
-        path_.push_optional_query_parameter("optionalEnd", &optional_end);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testNoResponseQueryParams",
-                    "/catalog/test-no-response-query-params",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_empty_response(response_).await
-    }
-    pub async fn test_boolean(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<bool, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/boolean");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testBoolean",
-                    "/catalog/boolean",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn test_double(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<f64, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/double");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testDouble",
-                    "/catalog/double",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn test_integer(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<i32, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/integer");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testInteger",
-                    "/catalog/integer",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_serializable_response(response_).await
-    }
-    pub async fn test_post_optional(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/boolean",
+        name = "testBoolean",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn test_boolean(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<bool, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/double",
+        name = "testDouble",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn test_double(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<f64, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/integer",
+        name = "testInteger",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    fn test_integer(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<i32, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/optional",
+        name = "testPostOptional",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    fn test_post_optional(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         maybe_string: Option<&str>,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_serializable_request(
-            &maybe_string,
-        );
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/optional");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testPostOptional",
-                    "/catalog/optional",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_default_serializable_response(response_)
-            .await
-    }
-    pub async fn test_optional_integer_and_double(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/optional-integer-double",
+        name = "testOptionalIntegerAndDouble",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    fn test_optional_integer_and_double(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[query(
+            name = "maybeInteger",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         maybe_integer: Option<i32>,
+        #[query(
+            name = "maybeDouble",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         maybe_double: Option<f64>,
-    ) -> Result<(), conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::async_encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/optional-integer-double");
-        path_.push_optional_query_parameter("maybeInteger", &maybe_integer);
-        path_.push_optional_query_parameter("maybeDouble", &maybe_double);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testOptionalIntegerAndDouble",
-                    "/catalog/optional-integer-double",
-                ),
-            );
-        let response_ = self.0.send(request_).await?;
-        conjure_http::private::async_decode_empty_response(response_).await
-    }
+    ) -> Result<(), conjure_http::private::Error>;
 }
 ///A Markdown description of the service.
-#[derive(Clone, Debug)]
-pub struct TestServiceClient<T>(T);
-impl<T> conjure_http::client::Service<T> for TestServiceClient<T>
-where
-    T: conjure_http::client::Client,
-{
-    fn new(client: T) -> Self {
-        TestServiceClient(client)
-    }
-}
-impl<T> TestServiceClient<T>
-where
-    T: conjure_http::client::Client,
-{
+#[conjure_http::conjure_client(name = "TestService")]
+pub trait AsyncTestService<
+    #[request_writer]
+    O,
+    #[response_body]
+    I: conjure_http::private::Stream<
+            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
+        >,
+> {
     ///Returns a mapping from file system id to backing file system configuration.
-    pub fn get_file_systems(
+    #[endpoint(
+        method = GET,
+        path = "/catalog/fileSystems",
+        name = "getFileSystems",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn get_file_systems(
         &self,
+        #[auth]
         auth_: &conjure_object::BearerToken,
     ) -> Result<
         std::collections::BTreeMap<
@@ -623,565 +398,348 @@ where
             super::super::super::objects::product::datasets::BackingFileSystem,
         >,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/fileSystems");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getFileSystems",
-                    "/catalog/fileSystems",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn create_dataset(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets",
+        name = "createDataset",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn create_dataset(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         request: &super::super::super::objects::product::CreateDatasetRequest,
+        #[header(
+            name = "Test-Header",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         test_header_arg: &str,
     ) -> Result<
         super::super::super::objects::product::datasets::Dataset,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::encode_serializable_request(&request);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_header(
-            &mut request_,
-            "test-header",
-            &test_header_arg,
-        )?;
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "createDataset",
-                    "/catalog/datasets",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn get_dataset(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}",
+        name = "getDataset",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn get_dataset(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
     ) -> Result<
         Option<super::super::super::objects::product::datasets::Dataset>,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getDataset",
-                    "/catalog/datasets/{datasetRid}",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn get_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw",
+        name = "getRawData",
+        accept = conjure_http::client::conjure::BinaryResponseDeserializer
+    )]
+    async fn get_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<T::ResponseBody, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getRawData",
-                    "/catalog/datasets/{datasetRid}/raw",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_binary_response(response_)
-    }
-    pub fn get_aliased_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<I, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw-aliased",
+        name = "getAliasedRawData",
+        accept = conjure_http::client::conjure::BinaryResponseDeserializer
+    )]
+    async fn get_aliased_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<T::ResponseBody, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getAliasedRawData",
-                    "/catalog/datasets/{datasetRid}/raw-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_binary_response(response_)
-    }
-    pub fn maybe_get_raw_data(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<I, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/raw-maybe",
+        name = "maybeGetRawData",
+        accept = conjure_http::client::conjure::OptionalBinaryResponseDeserializer
+    )]
+    async fn maybe_get_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<Option<T::ResponseBody>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/raw-maybe");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_binary_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "maybeGetRawData",
-                    "/catalog/datasets/{datasetRid}/raw-maybe",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_optional_binary_response(response_)
-    }
-    pub fn get_aliased_string(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<I>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/string-aliased",
+        name = "getAliasedString",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn get_aliased_string(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
     ) -> Result<
         super::super::super::objects::product::AliasedString,
         conjure_http::private::Error,
-    > {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/string-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getAliasedString",
-                    "/catalog/datasets/{datasetRid}/string-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn upload_raw_data<U>(
-        &self,
-        auth_: &conjure_object::BearerToken,
-        input: U,
-    ) -> Result<(), conjure_http::private::Error>
-    where
-        U: conjure_http::client::WriteBody<T::BodyWriter>,
-    {
-        let mut request_ = conjure_http::private::encode_binary_request(input);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets/upload-raw");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "uploadRawData",
-                    "/catalog/datasets/upload-raw",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_empty_response(response_)
-    }
-    pub fn upload_aliased_raw_data<U>(
-        &self,
-        auth_: &conjure_object::BearerToken,
-        input: U,
-    ) -> Result<(), conjure_http::private::Error>
-    where
-        U: conjure_http::client::WriteBody<T::BodyWriter>,
-    {
-        let mut request_ = conjure_http::private::encode_binary_request(input);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets/upload-raw-aliased");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "uploadAliasedRawData",
-                    "/catalog/datasets/upload-raw-aliased",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_empty_response(response_)
-    }
-    pub fn get_branches(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    >;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets/upload-raw",
+        name = "uploadRawData",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    async fn upload_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
+        input: impl conjure_http::client::AsyncWriteBody<O> + Sync + Send,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/datasets/upload-raw-aliased",
+        name = "uploadAliasedRawData",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    async fn upload_aliased_raw_data(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
+        input: impl conjure_http::client::AsyncWriteBody<O> + Sync + Send,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branches",
+        name = "getBranches",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn get_branches(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branches");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getBranches",
-                    "/catalog/datasets/{datasetRid}/branches",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
+    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error>;
     ///Gets all branches of this dataset.
-    #[deprecated(note = "use getBranches instead")]
-    pub fn get_branches_deprecated(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branchesDeprecated",
+        name = "getBranchesDeprecated",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn get_branches_deprecated(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branchesDeprecated");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "getBranchesDeprecated",
-                    "/catalog/datasets/{datasetRid}/branchesDeprecated",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn resolve_branch(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<std::collections::BTreeSet<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/branches/{branch}/resolve",
+        name = "resolveBranch",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn resolve_branch(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
+        #[path(name = "branch", encoder = conjure_http::client::conjure::PlainEncoder)]
         branch: &str,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/branches");
-        path_.push_path_parameter(&branch);
-        path_.push_literal("/resolve");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "resolveBranch",
-                    "/catalog/datasets/{datasetRid}/branches/{branch:.+}/resolve",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn test_param(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/datasets/{datasetRid}/testParam",
+        name = "testParam",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn test_param(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[path(
+            name = "datasetRid",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         dataset_rid: &conjure_object::ResourceIdentifier,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/datasets");
-        path_.push_path_parameter(&dataset_rid);
-        path_.push_literal("/testParam");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testParam",
-                    "/catalog/datasets/{datasetRid}/testParam",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn test_query_params(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/test-query-params",
+        name = "testQueryParams",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn test_query_params(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         query: &str,
+        #[query(
+            name = "different",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         something: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "optionalMiddle",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_middle: Option<&conjure_object::ResourceIdentifier>,
+        #[query(
+            name = "implicit",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         implicit: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "setEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         set_end: &std::collections::BTreeSet<String>,
+        #[query(
+            name = "optionalEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_end: Option<&conjure_object::ResourceIdentifier>,
-    ) -> Result<i32, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_serializable_request(&query);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/test-query-params");
-        path_.push_query_parameter("different", &something);
-        path_.push_optional_query_parameter("optionalMiddle", &optional_middle);
-        path_.push_query_parameter("implicit", &implicit);
-        path_.push_set_query_parameter("setEnd", &set_end);
-        path_.push_optional_query_parameter("optionalEnd", &optional_end);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testQueryParams",
-                    "/catalog/test-query-params",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn test_no_response_query_params(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<i32, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/test-no-response-query-params",
+        name = "testNoResponseQueryParams",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    async fn test_no_response_query_params(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         query: &str,
+        #[query(
+            name = "different",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         something: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "optionalMiddle",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_middle: Option<&conjure_object::ResourceIdentifier>,
+        #[query(
+            name = "implicit",
+            encoder = conjure_http::client::conjure::PlainEncoder
+        )]
         implicit: &conjure_object::ResourceIdentifier,
+        #[query(
+            name = "setEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         set_end: &std::collections::BTreeSet<String>,
+        #[query(
+            name = "optionalEnd",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         optional_end: Option<&conjure_object::ResourceIdentifier>,
-    ) -> Result<(), conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_serializable_request(&query);
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/test-no-response-query-params");
-        path_.push_query_parameter("different", &something);
-        path_.push_optional_query_parameter("optionalMiddle", &optional_middle);
-        path_.push_query_parameter("implicit", &implicit);
-        path_.push_set_query_parameter("setEnd", &set_end);
-        path_.push_optional_query_parameter("optionalEnd", &optional_end);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testNoResponseQueryParams",
-                    "/catalog/test-no-response-query-params",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_empty_response(response_)
-    }
-    pub fn test_boolean(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<bool, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/boolean");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testBoolean",
-                    "/catalog/boolean",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn test_double(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<f64, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/double");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testDouble",
-                    "/catalog/double",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn test_integer(
-        &self,
-        auth_: &conjure_object::BearerToken,
-    ) -> Result<i32, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/integer");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testInteger",
-                    "/catalog/integer",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_serializable_response(response_)
-    }
-    pub fn test_post_optional(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<(), conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/boolean",
+        name = "testBoolean",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn test_boolean(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<bool, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/double",
+        name = "testDouble",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn test_double(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<f64, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/integer",
+        name = "testInteger",
+        accept = conjure_http::client::StdResponseDeserializer
+    )]
+    async fn test_integer(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+    ) -> Result<i32, conjure_http::private::Error>;
+    #[endpoint(
+        method = POST,
+        path = "/catalog/optional",
+        name = "testPostOptional",
+        accept = conjure_http::client::conjure::CollectionResponseDeserializer
+    )]
+    async fn test_post_optional(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[body(serializer = conjure_http::client::StdRequestSerializer)]
         maybe_string: Option<&str>,
-    ) -> Result<Option<String>, conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_serializable_request(
-            &maybe_string,
-        );
-        *request_.method_mut() = conjure_http::private::http::Method::POST;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/optional");
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_serializable_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testPostOptional",
-                    "/catalog/optional",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_default_serializable_response(response_)
-    }
-    pub fn test_optional_integer_and_double(
-        &self,
-        auth_: &conjure_object::BearerToken,
+    ) -> Result<Option<String>, conjure_http::private::Error>;
+    #[endpoint(
+        method = GET,
+        path = "/catalog/optional-integer-double",
+        name = "testOptionalIntegerAndDouble",
+        accept = conjure_http::client::conjure::EmptyResponseDeserializer
+    )]
+    async fn test_optional_integer_and_double(
+        &self,
+        #[auth]
+        auth_: &conjure_object::BearerToken,
+        #[query(
+            name = "maybeInteger",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         maybe_integer: Option<i32>,
+        #[query(
+            name = "maybeDouble",
+            encoder = conjure_http::client::conjure::PlainSeqEncoder
+        )]
         maybe_double: Option<f64>,
-    ) -> Result<(), conjure_http::private::Error> {
-        let mut request_ = conjure_http::private::encode_empty_request();
-        *request_.method_mut() = conjure_http::private::http::Method::GET;
-        let mut path_ = conjure_http::private::UriBuilder::new();
-        path_.push_literal("/catalog/optional-integer-double");
-        path_.push_optional_query_parameter("maybeInteger", &maybe_integer);
-        path_.push_optional_query_parameter("maybeDouble", &maybe_double);
-        *request_.uri_mut() = path_.build();
-        conjure_http::private::encode_header_auth(&mut request_, auth_);
-        conjure_http::private::encode_empty_response_headers(&mut request_);
-        request_
-            .extensions_mut()
-            .insert(
-                conjure_http::client::Endpoint::new(
-                    "TestService",
-                    conjure_http::private::Option::None,
-                    "testOptionalIntegerAndDouble",
-                    "/catalog/optional-integer-double",
-                ),
-            );
-        let response_ = self.0.send(request_)?;
-        conjure_http::private::decode_empty_response(response_)
-    }
+    ) -> Result<(), conjure_http::private::Error>;
 }
diff --git a/conjure-codegen/src/example_types/objects/product/aliased_binary.rs b/conjure-codegen/src/example_types/objects/product/aliased_binary.rs
index 45a1aff1..3b51c8b7 100644
--- a/conjure-codegen/src/example_types/objects/product/aliased_binary.rs
+++ b/conjure-codegen/src/example_types/objects/product/aliased_binary.rs
@@ -43,3 +43,9 @@ impl std::ops::DerefMut for AliasedBinary {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::Bytes> for AliasedBinary {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::Bytes {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/aliased_string.rs b/conjure-codegen/src/example_types/objects/product/aliased_string.rs
index 5fd65b68..9d078e3b 100644
--- a/conjure-codegen/src/example_types/objects/product/aliased_string.rs
+++ b/conjure-codegen/src/example_types/objects/product/aliased_string.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for AliasedString {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for AliasedString {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/bearer_token_alias_example.rs b/conjure-codegen/src/example_types/objects/product/bearer_token_alias_example.rs
index c75ea790..7b6fcdb7 100644
--- a/conjure-codegen/src/example_types/objects/product/bearer_token_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/bearer_token_alias_example.rs
@@ -42,3 +42,9 @@ impl std::ops::DerefMut for BearerTokenAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::BearerToken> for BearerTokenAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::BearerToken {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/binary_alias_example.rs b/conjure-codegen/src/example_types/objects/product/binary_alias_example.rs
index f3f481d7..ea9a9f47 100644
--- a/conjure-codegen/src/example_types/objects/product/binary_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/binary_alias_example.rs
@@ -43,3 +43,9 @@ impl std::ops::DerefMut for BinaryAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::Bytes> for BinaryAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::Bytes {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/boolean_alias_example.rs b/conjure-codegen/src/example_types/objects/product/boolean_alias_example.rs
index 914dfc8e..8322922d 100644
--- a/conjure-codegen/src/example_types/objects/product/boolean_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/boolean_alias_example.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for BooleanAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<bool> for BooleanAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &bool {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/date_time_alias_example.rs b/conjure-codegen/src/example_types/objects/product/date_time_alias_example.rs
index b66dfe0d..c9b1ad90 100644
--- a/conjure-codegen/src/example_types/objects/product/date_time_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/date_time_alias_example.rs
@@ -51,3 +51,10 @@ impl std::ops::DerefMut for DateTimeAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::DateTime<conjure_object::Utc>>
+for DateTimeAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::DateTime<conjure_object::Utc> {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/double_alias_example.rs b/conjure-codegen/src/example_types/objects/product/double_alias_example.rs
index 75e1b96b..6d5d9a9e 100644
--- a/conjure-codegen/src/example_types/objects/product/double_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/double_alias_example.rs
@@ -53,3 +53,9 @@ impl std::ops::DerefMut for DoubleAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<f64> for DoubleAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &f64 {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/integer_alias_example.rs b/conjure-codegen/src/example_types/objects/product/integer_alias_example.rs
index 15df4f27..e4e6f813 100644
--- a/conjure-codegen/src/example_types/objects/product/integer_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/integer_alias_example.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for IntegerAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<i32> for IntegerAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &i32 {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/map_alias_example.rs b/conjure-codegen/src/example_types/objects/product/map_alias_example.rs
index bc2a3f93..8715862f 100644
--- a/conjure-codegen/src/example_types/objects/product/map_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/map_alias_example.rs
@@ -42,3 +42,10 @@ impl std::ops::DerefMut for MapAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<std::collections::BTreeMap<String, conjure_object::Any>>
+for MapAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &std::collections::BTreeMap<String, conjure_object::Any> {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/nested_aliased_binary.rs b/conjure-codegen/src/example_types/objects/product/nested_aliased_binary.rs
index 0937ef1f..7e197af8 100644
--- a/conjure-codegen/src/example_types/objects/product/nested_aliased_binary.rs
+++ b/conjure-codegen/src/example_types/objects/product/nested_aliased_binary.rs
@@ -43,3 +43,9 @@ impl std::ops::DerefMut for NestedAliasedBinary {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::Bytes> for NestedAliasedBinary {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::Bytes {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/nested_string_alias_example.rs b/conjure-codegen/src/example_types/objects/product/nested_string_alias_example.rs
index a84ba020..b008f53d 100644
--- a/conjure-codegen/src/example_types/objects/product/nested_string_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/nested_string_alias_example.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for NestedStringAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for NestedStringAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/reference_alias_example.rs b/conjure-codegen/src/example_types/objects/product/reference_alias_example.rs
index 3604df54..a0cb90a5 100644
--- a/conjure-codegen/src/example_types/objects/product/reference_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/reference_alias_example.rs
@@ -30,3 +30,9 @@ impl std::ops::DerefMut for ReferenceAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<super::AnyExample> for ReferenceAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &super::AnyExample {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/rid_alias_example.rs b/conjure-codegen/src/example_types/objects/product/rid_alias_example.rs
index 8ace9f1c..09413bc4 100644
--- a/conjure-codegen/src/example_types/objects/product/rid_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/rid_alias_example.rs
@@ -47,3 +47,9 @@ impl std::ops::DerefMut for RidAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::ResourceIdentifier> for RidAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::ResourceIdentifier {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/safe_long_alias_example.rs b/conjure-codegen/src/example_types/objects/product/safe_long_alias_example.rs
index d827c259..daccef8b 100644
--- a/conjure-codegen/src/example_types/objects/product/safe_long_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/safe_long_alias_example.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for SafeLongAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::SafeLong> for SafeLongAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::SafeLong {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/string_alias_example.rs b/conjure-codegen/src/example_types/objects/product/string_alias_example.rs
index 8ae498b0..aef8f571 100644
--- a/conjure-codegen/src/example_types/objects/product/string_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/string_alias_example.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for StringAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for StringAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/example_types/objects/product/uuid_alias_example.rs b/conjure-codegen/src/example_types/objects/product/uuid_alias_example.rs
index 63f5fadd..20d8b844 100644
--- a/conjure-codegen/src/example_types/objects/product/uuid_alias_example.rs
+++ b/conjure-codegen/src/example_types/objects/product/uuid_alias_example.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for UuidAliasExample {
         &mut self.0
     }
 }
+impl std::convert::AsRef<conjure_object::Uuid> for UuidAliasExample {
+    #[inline]
+    fn as_ref(&self) -> &conjure_object::Uuid {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/http_paths.rs b/conjure-codegen/src/http_paths.rs
deleted file mode 100644
index 33c48c8c..00000000
--- a/conjure-codegen/src/http_paths.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-pub enum PathSegment<'a> {
-    Literal(&'a str),
-    Parameter {
-        name: &'a str,
-        regex: Option<&'a str>,
-    },
-}
-
-pub fn parse(path: &str) -> impl Iterator<Item = PathSegment<'_>> {
-    path.split('/')
-        // skip the leading empty segment
-        .skip(1)
-        .map(
-            |segment| match segment.strip_prefix('{').and_then(|s| s.strip_suffix('}')) {
-                Some(segment) => {
-                    let mut it = segment.splitn(2, ':');
-                    PathSegment::Parameter {
-                        name: it.next().unwrap(),
-                        regex: it.next(),
-                    }
-                }
-                None => PathSegment::Literal(segment),
-            },
-        )
-}
diff --git a/conjure-codegen/src/lib.rs b/conjure-codegen/src/lib.rs
index 8716ff5d..cf52bbdf 100644
--- a/conjure-codegen/src/lib.rs
+++ b/conjure-codegen/src/lib.rs
@@ -205,7 +205,7 @@
 //! Synchronous:
 //! ```
 //! use conjure_http::client::Service;
-//! # use conjure_codegen::example_types::clients::another::TestServiceClient;
+//! # use conjure_codegen::example_types::clients::another::{TestService, TestServiceClient};
 //! # fn foo<T: conjure_http::client::Client>(http_client: T) -> Result<(), conjure_error::Error> {
 //! # let auth_token = "foobar".parse().unwrap();
 //! let client = TestServiceClient::new(http_client);
@@ -217,10 +217,10 @@
 //! Asynchronous:
 //! ```
 //! use conjure_http::client::AsyncService;
-//! # use conjure_codegen::example_types::clients::another::TestServiceAsyncClient;
-//! # async fn foo<T: conjure_http::client::AsyncClient>(http_client: T) -> Result<(), conjure_error::Error> {
+//! # use conjure_codegen::example_types::clients::another::{AsyncTestService, AsyncTestServiceClient};
+//! # async fn foo<T>(http_client: T) -> Result<(), conjure_error::Error> where T: conjure_http::client::AsyncClient + Sync + Send, T::ResponseBody: 'static + Send {
 //! # let auth_token = "foobar".parse().unwrap();
-//! let client = TestServiceAsyncClient::new(http_client);
+//! let client = AsyncTestServiceClient::new(http_client);
 //! let file_systems = client.get_file_systems(&auth_token).await?;
 //! # Ok(())
 //! # }
@@ -304,7 +304,6 @@ mod clients;
 mod context;
 mod enums;
 mod errors;
-mod http_paths;
 mod objects;
 mod servers;
 #[allow(dead_code, clippy::all)]
@@ -505,8 +504,10 @@ impl Config {
             let type_ = Type {
                 module_name: context.module_name(def.service_name()),
                 type_names: vec![
+                    format!("{}", def.service_name().name()),
                     format!("{}Client", def.service_name().name()),
-                    format!("{}AsyncClient", def.service_name().name()),
+                    format!("Async{}", def.service_name().name()),
+                    format!("Async{}Client", def.service_name().name()),
                 ],
                 contents,
             };
diff --git a/conjure-codegen/src/types/objects/argument_name.rs b/conjure-codegen/src/types/objects/argument_name.rs
index 3fbce4b0..356baf4b 100644
--- a/conjure-codegen/src/types/objects/argument_name.rs
+++ b/conjure-codegen/src/types/objects/argument_name.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for ArgumentName {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for ArgumentName {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/documentation.rs b/conjure-codegen/src/types/objects/documentation.rs
index cbcf6ee8..729cfd43 100644
--- a/conjure-codegen/src/types/objects/documentation.rs
+++ b/conjure-codegen/src/types/objects/documentation.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for Documentation {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for Documentation {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/endpoint_name.rs b/conjure-codegen/src/types/objects/endpoint_name.rs
index b6a3a11a..e79d8b3c 100644
--- a/conjure-codegen/src/types/objects/endpoint_name.rs
+++ b/conjure-codegen/src/types/objects/endpoint_name.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for EndpointName {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for EndpointName {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/error_namespace.rs b/conjure-codegen/src/types/objects/error_namespace.rs
index d18174fe..bad8fdcf 100644
--- a/conjure-codegen/src/types/objects/error_namespace.rs
+++ b/conjure-codegen/src/types/objects/error_namespace.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for ErrorNamespace {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for ErrorNamespace {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/field_name.rs b/conjure-codegen/src/types/objects/field_name.rs
index 6af3bf44..f256238f 100644
--- a/conjure-codegen/src/types/objects/field_name.rs
+++ b/conjure-codegen/src/types/objects/field_name.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for FieldName {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for FieldName {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/http_path.rs b/conjure-codegen/src/types/objects/http_path.rs
index 79180a25..c0195766 100644
--- a/conjure-codegen/src/types/objects/http_path.rs
+++ b/conjure-codegen/src/types/objects/http_path.rs
@@ -48,3 +48,9 @@ impl std::ops::DerefMut for HttpPath {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for HttpPath {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-codegen/src/types/objects/parameter_id.rs b/conjure-codegen/src/types/objects/parameter_id.rs
index 1ada4b75..f76c1096 100644
--- a/conjure-codegen/src/types/objects/parameter_id.rs
+++ b/conjure-codegen/src/types/objects/parameter_id.rs
@@ -49,3 +49,9 @@ impl std::ops::DerefMut for ParameterId {
         &mut self.0
     }
 }
+impl std::convert::AsRef<String> for ParameterId {
+    #[inline]
+    fn as_ref(&self) -> &String {
+        &self.0
+    }
+}
diff --git a/conjure-test/src/test/clients.rs b/conjure-test/src/test/clients.rs
index 2bcffa4e..b39f4126 100644
--- a/conjure-test/src/test/clients.rs
+++ b/conjure-test/src/test/clients.rs
@@ -206,7 +206,7 @@ macro_rules! check {
         let response = $call.unwrap();
         assert_eq!(response, $expected_response);
 
-        let $client = TestServiceAsyncClient::new(&raw_client);
+        let $client = AsyncTestServiceClient::new(&raw_client);
         let response = executor::block_on($call).unwrap();
         assert_eq!(response, $expected_response);
     }};
@@ -453,7 +453,6 @@ fn unexpected_json_response() {
 fn json_request() {
     let client = TestClient::new(Method::POST, "/test/jsonRequest")
         .header("Content-Type", "application/json")
-        .header("Content-Length", "13")
         .header("Accept", "application/json")
         .body(TestBody::Json(r#""hello world""#.to_string()));
     check!(client, client.json_request("hello world"));
@@ -463,14 +462,12 @@ fn json_request() {
 fn optional_json_request() {
     let client = TestClient::new(Method::POST, "/test/optionalJsonRequest")
         .header("Content-Type", "application/json")
-        .header("Content-Length", "13")
         .header("Accept", "application/json")
         .body(TestBody::Json(r#""hello world""#.to_string()));
     check!(client, client.optional_json_request(Some("hello world")));
 
     let client = TestClient::new(Method::POST, "/test/optionalJsonRequest")
         .header("Content-Type", "application/json")
-        .header("Content-Length", "4")
         .header("Accept", "application/json")
         .body(TestBody::Json("null".to_string()));
     check!(client, client.optional_json_request(None));