hook0_client/generated/

api.rs

// Generated by hook0-sdkgen from the OpenAPI snapshot the API crate commits.
// Do not edit by hand: run `UPDATE_SDK=rust cargo test -p hook0-sdkgen sdk_targets` and commit the result.
//! One method per operation the API declares, grouped by the entity its operation id
//! names, and the seam every one of them is issued through.
//!
//! How many arguments a method takes is the document's business rather than this crate's:
//! an operation declaring a dozen parameters is asked for with a dozen arguments.
#![allow(clippy::too_many_arguments)]

use super::errors::RequestError;
use super::errors::problem_for;
use super::models::Application;
use super::models::ApplicationInfo;
use super::models::ApplicationPost;
use super::models::ApplicationSecret;
use super::models::ApplicationSecretPost;
use super::models::Event;
use super::models::EventPost;
use super::models::EventType;
use super::models::EventTypePost;
use super::models::EventWithPayload;
use super::models::EventsPerDayEntry;
use super::models::IngestedEvent;
use super::models::InstanceConfig;
use super::models::Problem;
use super::models::QuotasResponse;
use super::models::ReplayEvent;
use super::models::RequestAttempt;
use super::models::Response;
use super::models::ServiceToken;
use super::models::ServiceTokenPost;
use super::models::Subscription;
use super::models::SubscriptionPost;

/// What a generated method issues its request through.
///
/// It is declared here rather than imported: the half of this crate that reaches the
/// network is hand-written and implements it, so neither half has to name what the other
/// declares, and nothing here carries a socket.
pub trait Transport {
    /// What this transport reports when it could not reach the API at all.
    type Error: std::error::Error + Send + Sync + 'static;

    /// Issues one request, answering the status the API replied with and the body it sent.
    fn request(
        &self,
        method: &str,
        path: &str,
        query: &[(&str, String)],
        body: Option<Vec<u8>>,
    ) -> impl std::future::Future<Output = Result<(u16, Vec<u8>), Self::Error>> + Send;
}

/// Writes a value the way a request line carries it, which is not always how it
/// is printed.
fn query_value(value: &dyn std::fmt::Display) -> String {
    value.to_string()
}

/// Writes a value as one segment of a path, with nothing left in it that could
/// name another one.
fn path_segment(value: &dyn std::fmt::Display) -> String {
    let rendered = query_value(value);
    let mut escaped = String::with_capacity(rendered.len());

    for byte in rendered.bytes() {
        let bare = byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~');
        if bare {
            escaped.push(char::from(byte));
        } else {
            escaped.push_str(&format!("%{byte:02X}"));
        }
    }

    escaped
}

/// What the API declares under `applicationSecrets`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct ApplicationSecretsApi<T> {
    transport: T,
}

impl<T: Transport> ApplicationSecretsApi<T> {
    /// Reaches what the API declares under `applicationSecrets`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `applicationSecrets.create`, `POST /api/v1/application_secrets/`.
    ///
    /// Create a new application secret
    pub async fn create(
        &self,
        body: ApplicationSecretPost,
    ) -> Result<ApplicationSecret, RequestError> {
        let path = "/api/v1/application_secrets/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `applicationSecrets.delete`, `DELETE /api/v1/application_secrets/{application_secret_token}`.
    ///
    /// Delete an application secret
    pub async fn delete(
        &self,
        application_secret_token: &str,
        application_id: &str,
    ) -> Result<(), RequestError> {
        let mut path = "/api/v1/application_secrets/{application_secret_token}".to_owned();
        path = path.replace(
            "{application_secret_token}",
            &path_segment(&application_secret_token),
        );
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("DELETE", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }

    /// `applicationSecrets.read`, `GET /api/v1/application_secrets/`.
    ///
    /// List application secrets
    pub async fn read(&self, application_id: &str) -> Result<Vec<ApplicationSecret>, RequestError> {
        let path = "/api/v1/application_secrets/".to_owned();
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `applicationSecrets.update`, `PUT /api/v1/application_secrets/{application_secret_token}`.
    ///
    /// Update an application secret
    pub async fn update(
        &self,
        application_secret_token: &str,
        body: ApplicationSecretPost,
    ) -> Result<ApplicationSecret, RequestError> {
        let mut path = "/api/v1/application_secrets/{application_secret_token}".to_owned();
        path = path.replace(
            "{application_secret_token}",
            &path_segment(&application_secret_token),
        );
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("PUT", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `applications`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct ApplicationsApi<T> {
    transport: T,
}

impl<T: Transport> ApplicationsApi<T> {
    /// Reaches what the API declares under `applications`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `applications.create`, `POST /api/v1/applications/`.
    ///
    /// Create a new application
    pub async fn create(&self, body: ApplicationPost) -> Result<Application, RequestError> {
        let path = "/api/v1/applications/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `applications.delete`, `DELETE /api/v1/applications/{application_id}`.
    ///
    /// Delete an application
    pub async fn delete(&self, application_id: &str) -> Result<(), RequestError> {
        let mut path = "/api/v1/applications/{application_id}".to_owned();
        path = path.replace("{application_id}", &path_segment(&application_id));
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("DELETE", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }

    /// `applications.get`, `GET /api/v1/applications/{application_id}`.
    ///
    /// Get an application by its ID
    pub async fn get(&self, application_id: &str) -> Result<ApplicationInfo, RequestError> {
        let mut path = "/api/v1/applications/{application_id}".to_owned();
        path = path.replace("{application_id}", &path_segment(&application_id));
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `applications.list`, `GET /api/v1/applications/`.
    ///
    /// List applications
    pub async fn list(&self, organization_id: &str) -> Result<Vec<Application>, RequestError> {
        let path = "/api/v1/applications/".to_owned();
        let query: Vec<(&str, String)> = vec![("organization_id", query_value(&organization_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `applications.update`, `PUT /api/v1/applications/{application_id}`.
    ///
    /// Edit an application
    pub async fn update(
        &self,
        application_id: &str,
        body: ApplicationPost,
    ) -> Result<Application, RequestError> {
        let mut path = "/api/v1/applications/{application_id}".to_owned();
        path = path.replace("{application_id}", &path_segment(&application_id));
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("PUT", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `errors`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct ErrorsApi<T> {
    transport: T,
}

impl<T: Transport> ErrorsApi<T> {
    /// Reaches what the API declares under `errors`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `errors.list`, `GET /api/v1/errors/`.
    ///
    /// List errors
    pub async fn list(&self) -> Result<Vec<Problem>, RequestError> {
        let path = "/api/v1/errors/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `eventTypes`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct EventTypesApi<T> {
    transport: T,
}

impl<T: Transport> EventTypesApi<T> {
    /// Reaches what the API declares under `eventTypes`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `eventTypes.create`, `POST /api/v1/event_types/`.
    ///
    /// Create a new event type
    pub async fn create(&self, body: EventTypePost) -> Result<EventType, RequestError> {
        let path = "/api/v1/event_types/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `eventTypes.delete`, `DELETE /api/v1/event_types/{event_type_name}`.
    ///
    /// Delete an event type
    pub async fn delete(
        &self,
        event_type_name: &str,
        application_id: &str,
    ) -> Result<(), RequestError> {
        let mut path = "/api/v1/event_types/{event_type_name}".to_owned();
        path = path.replace("{event_type_name}", &path_segment(&event_type_name));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("DELETE", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }

    /// `eventTypes.get`, `GET /api/v1/event_types/{event_type_name}`.
    ///
    /// Get an event type by its name
    pub async fn get(
        &self,
        event_type_name: &str,
        application_id: &str,
    ) -> Result<EventType, RequestError> {
        let mut path = "/api/v1/event_types/{event_type_name}".to_owned();
        path = path.replace("{event_type_name}", &path_segment(&event_type_name));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `eventTypes.list`, `GET /api/v1/event_types/`.
    ///
    /// List event types
    pub async fn list(&self, application_id: &str) -> Result<Vec<EventType>, RequestError> {
        let path = "/api/v1/event_types/".to_owned();
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `events`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct EventsApi<T> {
    transport: T,
}

impl<T: Transport> EventsApi<T> {
    /// Reaches what the API declares under `events`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `events.get`, `GET /api/v1/events/{event_id}`.
    ///
    /// Get an event by its ID
    pub async fn get(
        &self,
        event_id: &str,
        application_id: &str,
    ) -> Result<EventWithPayload, RequestError> {
        let mut path = "/api/v1/events/{event_id}".to_owned();
        path = path.replace("{event_id}", &path_segment(&event_id));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `events.ingest`, `POST /api/v1/event/`.
    ///
    /// Ingest an event
    pub async fn ingest(&self, body: EventPost) -> Result<IngestedEvent, RequestError> {
        let path = "/api/v1/event/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `events.list`, `GET /api/v1/events/`.
    ///
    /// List latest events
    pub async fn list(&self, application_id: &str) -> Result<Vec<Event>, RequestError> {
        let path = "/api/v1/events/".to_owned();
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `events.replay`, `POST /api/v1/events/{event_id}/replay`.
    ///
    /// Replay an event
    pub async fn replay(&self, event_id: &str, body: ReplayEvent) -> Result<(), RequestError> {
        let mut path = "/api/v1/events/{event_id}/replay".to_owned();
        path = path.replace("{event_id}", &path_segment(&event_id));
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }
}

/// What the API declares under `events_per_day`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct EventsPerDayApi<T> {
    transport: T,
}

impl<T: Transport> EventsPerDayApi<T> {
    /// Reaches what the API declares under `events_per_day`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `events_per_day.list_for_application`, `GET /api/v1/events_per_day/application`.
    ///
    /// List events per day for an application
    pub async fn list_for_application(
        &self,
        application_id: &str,
        from: Option<&str>,
        to: Option<&str>,
    ) -> Result<Vec<EventsPerDayEntry>, RequestError> {
        let path = "/api/v1/events_per_day/application".to_owned();
        let mut query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        if let Some(from) = from {
            query.push(("from", query_value(&from)));
        }
        if let Some(to) = to {
            query.push(("to", query_value(&to)));
        }
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `events_per_day.list_for_organization`, `GET /api/v1/events_per_day/organization`.
    ///
    /// List events per day for an organization
    pub async fn list_for_organization(
        &self,
        organization_id: &str,
        from: Option<&str>,
        to: Option<&str>,
    ) -> Result<Vec<EventsPerDayEntry>, RequestError> {
        let path = "/api/v1/events_per_day/organization".to_owned();
        let mut query: Vec<(&str, String)> =
            vec![("organization_id", query_value(&organization_id))];
        if let Some(from) = from {
            query.push(("from", query_value(&from)));
        }
        if let Some(to) = to {
            query.push(("to", query_value(&to)));
        }
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `instance`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct InstanceApi<T> {
    transport: T,
}

impl<T: Transport> InstanceApi<T> {
    /// Reaches what the API declares under `instance`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `instance.get`, `GET /api/v1/instance/`.
    ///
    /// Get instance configuration
    pub async fn get(&self) -> Result<InstanceConfig, RequestError> {
        let path = "/api/v1/instance/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `payload_content_types`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct PayloadContentTypesApi<T> {
    transport: T,
}

impl<T: Transport> PayloadContentTypesApi<T> {
    /// Reaches what the API declares under `payload_content_types`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `payload_content_types.list`, `GET /api/v1/payload_content_types/`.
    ///
    /// List supported event payload content types
    pub async fn list(&self) -> Result<Vec<String>, RequestError> {
        let path = "/api/v1/payload_content_types/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `quotas`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct QuotasApi<T> {
    transport: T,
}

impl<T: Transport> QuotasApi<T> {
    /// Reaches what the API declares under `quotas`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `quotas.get`, `GET /api/v1/quotas/`.
    ///
    /// Get quotas
    pub async fn get(&self) -> Result<QuotasResponse, RequestError> {
        let path = "/api/v1/quotas/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `requestAttempts`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct RequestAttemptsApi<T> {
    transport: T,
}

impl<T: Transport> RequestAttemptsApi<T> {
    /// Reaches what the API declares under `requestAttempts`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `requestAttempts.get`, `GET /api/v1/request_attempts/{request_attempt_id}`.
    ///
    /// Get a request attempt by its ID
    pub async fn get(
        &self,
        request_attempt_id: &str,
        application_id: &str,
    ) -> Result<RequestAttempt, RequestError> {
        let mut path = "/api/v1/request_attempts/{request_attempt_id}".to_owned();
        path = path.replace("{request_attempt_id}", &path_segment(&request_attempt_id));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `requestAttempts.read`, `GET /api/v1/request_attempts/`.
    ///
    /// List request attempts
    pub async fn read(
        &self,
        application_id: &str,
        event_event_type_names: Option<&str>,
        event_id: Option<&str>,
        max_created_at: Option<&str>,
        min_created_at: Option<&str>,
        pagination_cursor: Option<&str>,
        subscription_id: Option<&str>,
    ) -> Result<Vec<RequestAttempt>, RequestError> {
        let path = "/api/v1/request_attempts/".to_owned();
        let mut query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        if let Some(event_event_type_names) = event_event_type_names {
            query.push((
                "event.event_type_names",
                query_value(&event_event_type_names),
            ));
        }
        if let Some(event_id) = event_id {
            query.push(("event_id", query_value(&event_id)));
        }
        if let Some(max_created_at) = max_created_at {
            query.push(("max_created_at", query_value(&max_created_at)));
        }
        if let Some(min_created_at) = min_created_at {
            query.push(("min_created_at", query_value(&min_created_at)));
        }
        if let Some(pagination_cursor) = pagination_cursor {
            query.push(("pagination_cursor", query_value(&pagination_cursor)));
        }
        if let Some(subscription_id) = subscription_id {
            query.push(("subscription_id", query_value(&subscription_id)));
        }
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `response`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct ResponseApi<T> {
    transport: T,
}

impl<T: Transport> ResponseApi<T> {
    /// Reaches what the API declares under `response`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `response.get`, `GET /api/v1/responses/{response_id}`.
    ///
    /// Get a response by its ID
    pub async fn get(
        &self,
        response_id: &str,
        application_id: &str,
    ) -> Result<Response, RequestError> {
        let mut path = "/api/v1/responses/{response_id}".to_owned();
        path = path.replace("{response_id}", &path_segment(&response_id));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `serviceToken`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct ServiceTokenApi<T> {
    transport: T,
}

impl<T: Transport> ServiceTokenApi<T> {
    /// Reaches what the API declares under `serviceToken`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `serviceToken.create`, `POST /api/v1/service_token/`.
    ///
    /// Create a new service token
    pub async fn create(&self, body: ServiceTokenPost) -> Result<ServiceToken, RequestError> {
        let path = "/api/v1/service_token/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `serviceToken.delete`, `DELETE /api/v1/service_token/{service_token_id}`.
    ///
    /// Delete a service token
    pub async fn delete(
        &self,
        service_token_id: &str,
        organization_id: &str,
    ) -> Result<(), RequestError> {
        let mut path = "/api/v1/service_token/{service_token_id}".to_owned();
        path = path.replace("{service_token_id}", &path_segment(&service_token_id));
        let query: Vec<(&str, String)> = vec![("organization_id", query_value(&organization_id))];
        let issued = self.transport.request("DELETE", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }

    /// `serviceToken.edit`, `PUT /api/v1/service_token/{service_token_id}`.
    ///
    /// Edit a service token
    pub async fn edit(
        &self,
        service_token_id: &str,
        body: ServiceTokenPost,
    ) -> Result<ServiceToken, RequestError> {
        let mut path = "/api/v1/service_token/{service_token_id}".to_owned();
        path = path.replace("{service_token_id}", &path_segment(&service_token_id));
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("PUT", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `serviceToken.get`, `GET /api/v1/service_token/{service_token_id}`.
    ///
    /// Get a service token
    pub async fn get(
        &self,
        service_token_id: &str,
        organization_id: &str,
    ) -> Result<ServiceToken, RequestError> {
        let mut path = "/api/v1/service_token/{service_token_id}".to_owned();
        path = path.replace("{service_token_id}", &path_segment(&service_token_id));
        let query: Vec<(&str, String)> = vec![("organization_id", query_value(&organization_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `serviceToken.list`, `GET /api/v1/service_token/`.
    ///
    /// List service tokens
    pub async fn list(&self, organization_id: &str) -> Result<Vec<ServiceToken>, RequestError> {
        let path = "/api/v1/service_token/".to_owned();
        let query: Vec<(&str, String)> = vec![("organization_id", query_value(&organization_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}

/// What the API declares under `subscriptions`.
///
/// Every method of it is issued through the transport it is handed.
#[derive(Debug, Clone)]
pub struct SubscriptionsApi<T> {
    transport: T,
}

impl<T: Transport> SubscriptionsApi<T> {
    /// Reaches what the API declares under `subscriptions`.
    pub fn new(transport: T) -> Self {
        Self { transport }
    }

    /// `subscriptions.create`, `POST /api/v1/subscriptions/`.
    ///
    /// Create a new subscription
    pub async fn create(&self, body: SubscriptionPost) -> Result<Subscription, RequestError> {
        let path = "/api/v1/subscriptions/".to_owned();
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("POST", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `subscriptions.delete`, `DELETE /api/v1/subscriptions/{subscription_id}`.
    ///
    /// Delete a subscription
    pub async fn delete(
        &self,
        subscription_id: &str,
        application_id: &str,
    ) -> Result<(), RequestError> {
        let mut path = "/api/v1/subscriptions/{subscription_id}".to_owned();
        path = path.replace("{subscription_id}", &path_segment(&subscription_id));
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("DELETE", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        Ok(())
    }

    /// `subscriptions.get`, `GET /api/v1/subscriptions/{subscription_id}`.
    ///
    /// Get a subscription by its ID
    pub async fn get(&self, subscription_id: &str) -> Result<Subscription, RequestError> {
        let mut path = "/api/v1/subscriptions/{subscription_id}".to_owned();
        path = path.replace("{subscription_id}", &path_segment(&subscription_id));
        let query: Vec<(&str, String)> = Vec::new();
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `subscriptions.list`, `GET /api/v1/subscriptions/`.
    ///
    /// List subscriptions
    pub async fn list(&self, application_id: &str) -> Result<Vec<Subscription>, RequestError> {
        let path = "/api/v1/subscriptions/".to_owned();
        let query: Vec<(&str, String)> = vec![("application_id", query_value(&application_id))];
        let issued = self.transport.request("GET", &path, &query, None);
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }

    /// `subscriptions.update`, `PUT /api/v1/subscriptions/{subscription_id}`.
    ///
    /// Update a subscription
    pub async fn update(
        &self,
        subscription_id: &str,
        body: SubscriptionPost,
    ) -> Result<Subscription, RequestError> {
        let mut path = "/api/v1/subscriptions/{subscription_id}".to_owned();
        path = path.replace("{subscription_id}", &path_segment(&subscription_id));
        let query: Vec<(&str, String)> = Vec::new();
        let body = serde_json::to_vec(&body).map_err(RequestError::unwritable)?;
        let issued = self.transport.request("PUT", &path, &query, Some(body));
        let (status, payload) = issued.await.map_err(RequestError::transport)?;

        if let Some(failure) = problem_for(status, &payload) {
            return Err(RequestError::Api(Box::new(failure)));
        }

        let read = serde_json::from_slice(&payload);
        read.map_err(|cause| RequestError::unreadable(status, &payload, &cause))
    }
}