/*
* Zernio API
*
* API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api Versioning and deprecation: all endpoints are versioned in the URL path (current version: /v1). Breaking changes only ship in a new path version; existing versions keep working. Deprecated operations are marked 'deprecated: true' in this spec and announced in the changelog (https://zernio.com/changelog) before removal. Errors: every 4xx/5xx response is application/json with a machine-readable 'code' and a human-readable 'error' message (see the ErrorResponse schema). Request ids: responses carry an X-Request-Id header with the id we log the request under. Quote it when reporting a problem. A valid x-request-id you send is reused as that id.
*
* The version of the OpenAPI document: 1.531.0
* Contact: support@zernio.com
* Generated by: https://openapi-generator.tech
*/
use super::{configuration, ContentType, Error};
use crate::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};
/// struct for typed errors of method [`create_creator_payout_login`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateCreatorPayoutLoginError {
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`get_creator_payout_statement`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCreatorPayoutStatementError {
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`get_creator_payouts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCreatorPayoutsError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`get_creator_portal`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCreatorPortalError {
Status404(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`join_creator_campaign`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum JoinCreatorCampaignError {
Status400(models::ErrorResponse),
Status403(models::ErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`recover_creator_portal_links`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RecoverCreatorPortalLinksError {
Status400(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`remove_creator_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveCreatorAccountError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`start_creator_connect`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum StartCreatorConnectError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`start_creator_payouts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum StartCreatorPayoutsError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`submit_creator_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SubmitCreatorPostError {
Status400(models::ErrorResponse),
Status403(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// Returns a one-time link into the creator's Stripe Express dashboard, where they change bank details and see each payout. Only after the creator submitted their payout details. About 20 attempts per participant every 10 minutes.
pub async fn create_creator_payout_login(
configuration: &configuration::Configuration,
token: &str,
) -> Result<models::StartCreatorPayouts200Response, Error<CreateCreatorPayoutLoginError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/payout-login",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::StartCreatorPayouts200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::StartCreatorPayouts200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateCreatorPayoutLoginError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// A PDF statement of one paid payout to this creator: who paid, the campaign, the date, the amount and the Stripe transfer id. It is a statement of a payment, not a tax invoice. Only for a paid payout of this participant; anything else answers 404. About 60 downloads per participant every 10 minutes.
pub async fn get_creator_payout_statement(
configuration: &configuration::Configuration,
token: &str,
transfer_id: &str,
) -> Result<reqwest::Response, Error<GetCreatorPayoutStatementError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_path_transfer_id = transfer_id;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/payouts/{transferId}/statement",
configuration.base_path,
token = crate::apis::urlencode(p_path_token),
transferId = crate::apis::urlencode(p_path_transfer_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
if !status.is_client_error() && !status.is_server_error() {
Ok(resp)
} else {
let content = resp.text().await?;
let entity: Option<GetCreatorPayoutStatementError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// The participant's ledger entries, newest first, with the bucket each one moved money from and to (`accruing`, `owed`, `payable`, `settling`, `settled`; null for the other side), plus the payout setup. Never cached.
pub async fn get_creator_payouts(
configuration: &configuration::Configuration,
token: &str,
limit: Option<i32>,
skip: Option<i32>,
) -> Result<models::GetCreatorPayouts200Response, Error<GetCreatorPayoutsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_query_limit = limit;
let p_query_skip = skip;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/payouts",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_skip {
req_builder = req_builder.query(&[("skip", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetCreatorPayouts200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetCreatorPayouts200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<GetCreatorPayoutsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// What a creator sees behind a campaign link, with no API key. Never cached. `token` is one of: - An open invite token (from `POST /v1/creator-campaigns/{campaignId}/invite-link`): answers `kind: invite` with the campaign only. - A participant token (from an invite or a join): answers `kind: participant` with the creator's connected accounts, latest 100 submissions, earnings and payout setup. Reading a participant page also re-checks the creator's connected accounts.
pub async fn get_creator_portal(
configuration: &configuration::Configuration,
token: &str,
) -> Result<models::GetCreatorPortal200Response, Error<GetCreatorPortalError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let uri_str = format!(
"{}/public/creator-campaigns/{token}",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetCreatorPortal200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetCreatorPortal200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<GetCreatorPortalError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Accepts a participant invite, or joins through an open invite link. - Participant token: the body is ignored and the invite is accepted. - Open invite token: a new participant is created from `displayName` (required) and `email` (optional), and a fresh participant token comes back. Keep it: it is the creator's only key to their page. Open-link joins are limited to about 20 per IP address and 60 per link every 10 minutes.
pub async fn join_creator_campaign(
configuration: &configuration::Configuration,
token: &str,
join_creator_campaign_request: Option<models::JoinCreatorCampaignRequest>,
) -> Result<models::JoinCreatorCampaign201Response, Error<JoinCreatorCampaignError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_join_creator_campaign_request = join_creator_campaign_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body_join_creator_campaign_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::JoinCreatorCampaign201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::JoinCreatorCampaign201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<JoinCreatorCampaignError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// For a creator who lost their link. Emails every personal participant link held by `email` in one message, optionally only the one for `campaignId`. - Removed participants and draft campaigns are left out. - Always answers 202 with the same body, so the answer never tells whether the address has links. - Limited to 5 requests per hour per email address and 5 per hour per IP address.
pub async fn recover_creator_portal_links(
configuration: &configuration::Configuration,
recover_creator_portal_links_request: models::RecoverCreatorPortalLinksRequest,
) -> Result<models::RecoverCreatorPortalLinks202Response, Error<RecoverCreatorPortalLinksError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_body_recover_creator_portal_links_request = recover_creator_portal_links_request;
let uri_str = format!(
"{}/public/creator-campaigns/recover-link",
configuration.base_path
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body_recover_creator_portal_links_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RecoverCreatorPortalLinks202Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RecoverCreatorPortalLinks202Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RecoverCreatorPortalLinksError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Disconnects one of the creator's accounts. The account belongs to the creator, not to one campaign, so it stops counting in every campaign of this brand they joined. What its posts already earned stays: accrued, approved and paid amounts are not touched. Refused while a post from the account is still counting views, because those views are read through the account. It can be removed once their tracking ends.
pub async fn remove_creator_account(
configuration: &configuration::Configuration,
token: &str,
account_id: &str,
) -> Result<models::RemoveCreatorAccount200Response, Error<RemoveCreatorAccountError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_path_account_id = account_id;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/accounts/{accountId}",
configuration.base_path,
token = crate::apis::urlencode(p_path_token),
accountId = crate::apis::urlencode(p_path_account_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RemoveCreatorAccount200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RemoveCreatorAccount200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RemoveCreatorAccountError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Returns the authorization URL that connects one of the creator's own social accounts, read-only, so their posts can be verified. Send the creator's browser to `authUrl`; they come back to their participant page. Only the campaign's platforms are accepted.
pub async fn start_creator_connect(
configuration: &configuration::Configuration,
token: &str,
start_creator_connect_request: models::StartCreatorConnectRequest,
) -> Result<models::StartCreatorConnect200Response, Error<StartCreatorConnectError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_start_creator_connect_request = start_creator_connect_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/connect",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body_start_creator_connect_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::StartCreatorConnect200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::StartCreatorConnect200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<StartCreatorConnectError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// For a campaign that pays through the Zernio treasury: creates the creator's payee on first use and returns a Stripe-hosted onboarding link where they enter identity and bank details. `country` is required the first time and cannot change afterwards. About 20 attempts per participant every 10 minutes.
pub async fn start_creator_payouts(
configuration: &configuration::Configuration,
token: &str,
start_creator_payouts_request: models::StartCreatorPayoutsRequest,
) -> Result<models::StartCreatorPayouts200Response, Error<StartCreatorPayoutsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_start_creator_payouts_request = start_creator_payouts_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/payouts",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body_start_creator_payouts_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::StartCreatorPayouts200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::StartCreatorPayouts200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<StartCreatorPayoutsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Submits the link to a post the creator published from a connected account. The post opens a tracking window and fires `campaign_submission.received` to the operator. About 30 attempts and 10 accepted posts per participant every 10 minutes.
pub async fn submit_creator_post(
configuration: &configuration::Configuration,
token: &str,
submit_creator_post_request: models::SubmitCreatorPostRequest,
) -> Result<models::SubmitCreatorPost201Response, Error<SubmitCreatorPostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_submit_creator_post_request = submit_creator_post_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/submissions",
configuration.base_path,
token = crate::apis::urlencode(p_path_token)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body_submit_creator_post_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SubmitCreatorPost201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SubmitCreatorPost201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<SubmitCreatorPostError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}