/*
* 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.603.1
* 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 [`presign_creator_draft_upload`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PresignCreatorDraftUploadError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(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 [`request_creator_sample`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RequestCreatorSampleError {
Status400(models::ErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`set_creator_spark_code`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SetCreatorSparkCodeError {
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_draft`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SubmitCreatorDraftError {
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::CreateCreatorPayoutLogin200Response, 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::CreateCreatorPayoutLogin200Response`"))),
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::CreateCreatorPayoutLogin200Response`")))),
}
} 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, draft versions, sample requests, earnings and payout setup. A creator held for approval reads it with `participant.status` `pending` (or `denied` once turned away). 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. - On a campaign with `joinApproval: manual`, an open-link joiner lands `pending` and `campaign_participant.pending` fires instead of `campaign_participant.joined`. A pending creator holds no place under `caps.maxParticipants` (the limit is checked when the operator approves them) and cannot submit posts, drafts or sample requests until approved. Personal invites always get straight in. 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,
}))
}
}
/// Returns a presigned URL to upload one draft file to, on a campaign with `requireDraftApproval`. `PUT` the file to `uploadUrl` with the same `Content-Type`, then pass `publicUrl` as `mediaUrl` to `POST /public/creator-campaigns/{token}/drafts`. The URL expires after `expiresIn` seconds. Accepted files: MP4, MOV or WebM video, JPG, PNG or WebP image, up to 500 MB. About 20 uploads per participant every 10 minutes.
pub async fn presign_creator_draft_upload(
configuration: &configuration::Configuration,
token: &str,
presign_creator_draft_upload_request: models::PresignCreatorDraftUploadRequest,
) -> Result<models::PresignCreatorDraftUpload200Response, Error<PresignCreatorDraftUploadError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_presign_creator_draft_upload_request = presign_creator_draft_upload_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/drafts/upload",
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_presign_creator_draft_upload_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::PresignCreatorDraftUpload200Response`"))),
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::PresignCreatorDraftUpload200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<PresignCreatorDraftUploadError> = 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,
}))
}
}
/// Asks for a free sample of one of the campaign's `sampleProducts`, shipped to `shippingAddress`, and fires `campaign_sample.requested`. The request waits for the campaign team; on approval the creator gets a single-use discount code for the product. - A product with `variants` needs `variantId`. - One open request per product: asking again while one is pending, approved or shipped answers 409. A declined product can be asked again. About 10 requests per participant every 10 minutes.
pub async fn request_creator_sample(
configuration: &configuration::Configuration,
token: &str,
request_creator_sample_request: models::RequestCreatorSampleRequest,
) -> Result<models::RequestCreatorSample201Response, Error<RequestCreatorSampleError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_request_creator_sample_request = request_creator_sample_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/samples",
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_request_creator_sample_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::RequestCreatorSample201Response`"))),
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::RequestCreatorSample201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RequestCreatorSampleError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// The creator pastes the Spark code of one of their TikTok posts (generated in the TikTok app under the post's ad settings), so the brand can run the post as a Spark Ad under the creator's handle. Send `null` to clear it. The code is never returned: submissions only expose `hasSparkCode`.
pub async fn set_creator_spark_code(
configuration: &configuration::Configuration,
token: &str,
submission_id: &str,
set_creator_spark_code_request: models::SetCreatorSparkCodeRequest,
) -> Result<models::SetCreatorSparkCode200Response, Error<SetCreatorSparkCodeError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_path_submission_id = submission_id;
let p_body_set_creator_spark_code_request = set_creator_spark_code_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/submissions/{submissionId}/spark-code",
configuration.base_path,
token = crate::apis::urlencode(p_path_token),
submissionId = crate::apis::urlencode(p_path_submission_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &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_set_creator_spark_code_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::SetCreatorSparkCode200Response`"))),
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::SetCreatorSparkCode200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<SetCreatorSparkCodeError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Returns the URL that connects one of the creator's own social accounts, read-only, so their posts can be verified. Only the campaign's platforms are accepted. `authUrl` opens the welcome screen in the campaign's brand, then the platform's sign-in. The creator comes back to their participant page, or to the connect window's result screen when `windowUrl` is sent.
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,
}))
}
}
/// Sends a draft for the campaign team to review before the creator publishes, on a campaign with `requireDraftApproval`, and fires `campaign_draft.submitted`. `mediaUrl` must be a `publicUrl` from `POST /public/creator-campaigns/{token}/drafts/upload`. ### Revisions - Without `revisionOf` the draft starts a new chain at version 1. - With `revisionOf` it is the next version of that chain. Only one of the creator's own versions marked `revision_requested` takes a new version, and only once. About 20 drafts per participant every 10 minutes.
pub async fn submit_creator_draft(
configuration: &configuration::Configuration,
token: &str,
submit_creator_draft_request: models::SubmitCreatorDraftRequest,
) -> Result<models::SubmitCreatorDraft201Response, Error<SubmitCreatorDraftError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_token = token;
let p_body_submit_creator_draft_request = submit_creator_draft_request;
let uri_str = format!(
"{}/public/creator-campaigns/{token}/drafts",
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_draft_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::SubmitCreatorDraft201Response`"))),
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::SubmitCreatorDraft201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<SubmitCreatorDraftError> = 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,
}))
}
}