use std::error;
use std::fmt;
#[derive(Debug, Clone)]
pub struct ResponseContent<T> {
pub status: reqwest::StatusCode,
pub content: String,
pub entity: Option<T>,
}
#[derive(Debug)]
pub enum Error<T> {
Reqwest(reqwest::Error),
Serde(serde_json::Error),
Io(std::io::Error),
ResponseError(ResponseContent<T>),
}
impl <T> fmt::Display for Error<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (module, e) = match self {
Error::Reqwest(e) => ("reqwest", e.to_string()),
Error::Serde(e) => ("serde", e.to_string()),
Error::Io(e) => ("IO", e.to_string()),
Error::ResponseError(e) => ("response", format!("status code {}", e.status)),
};
write!(f, "error in {}: {}", module, e)
}
}
impl <T: fmt::Debug> error::Error for Error<T> {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
Some(match self {
Error::Reqwest(e) => e,
Error::Serde(e) => e,
Error::Io(e) => e,
Error::ResponseError(_) => return None,
})
}
}
impl <T> From<reqwest::Error> for Error<T> {
fn from(e: reqwest::Error) -> Self {
Error::Reqwest(e)
}
}
impl <T> From<serde_json::Error> for Error<T> {
fn from(e: serde_json::Error) -> Self {
Error::Serde(e)
}
}
impl <T> From<std::io::Error> for Error<T> {
fn from(e: std::io::Error) -> Self {
Error::Io(e)
}
}
pub fn urlencode<T: AsRef<str>>(s: T) -> String {
::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
}
pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> {
if let serde_json::Value::Object(object) = value {
let mut params = vec![];
for (key, value) in object {
match value {
serde_json::Value::Object(_) => params.append(&mut parse_deep_object(
&format!("{}[{}]", prefix, key),
value,
)),
serde_json::Value::Array(array) => {
for (i, value) in array.iter().enumerate() {
params.append(&mut parse_deep_object(
&format!("{}[{}][{}]", prefix, key, i),
value,
));
}
},
serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())),
_ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
}
}
return params;
}
unimplemented!("Only objects are supported with style=deepObject")
}
#[allow(dead_code)]
enum ContentType {
Json,
Text,
Unsupported(String)
}
impl From<&str> for ContentType {
fn from(content_type: &str) -> Self {
if content_type.starts_with("application") && content_type.contains("json") {
return Self::Json;
} else if content_type.starts_with("text/plain") {
return Self::Text;
} else {
return Self::Unsupported(content_type.to_string());
}
}
}
pub mod activity_api;
pub mod billing_api;
pub mod channel_connections_api;
pub mod channel_endpoints_api;
pub mod contexts_api;
pub mod events_api;
pub mod feature_flags_api;
pub mod health_api;
pub mod inbound_parse_api;
pub mod inbox_api;
pub mod integrations_api;
pub mod layouts_api;
pub mod messages_api;
pub mod metrics_api;
pub mod notification_groups_api;
pub mod notifications_api;
pub mod preferences_api;
pub mod projects_api;
pub mod subscriber_credentials_api;
pub mod subscribers_api;
pub mod topics_api;
pub mod translations_api;
pub mod webhooks_api;
pub mod workflows_api;
pub mod configuration;
use std::sync::Arc;
pub trait Api {
fn activity_api(&self) -> &dyn activity_api::ActivityApi;
fn billing_api(&self) -> &dyn billing_api::BillingApi;
fn channel_connections_api(&self) -> &dyn channel_connections_api::ChannelConnectionsApi;
fn channel_endpoints_api(&self) -> &dyn channel_endpoints_api::ChannelEndpointsApi;
fn contexts_api(&self) -> &dyn contexts_api::ContextsApi;
fn events_api(&self) -> &dyn events_api::EventsApi;
fn feature_flags_api(&self) -> &dyn feature_flags_api::FeatureFlagsApi;
fn health_api(&self) -> &dyn health_api::HealthApi;
fn inbound_parse_api(&self) -> &dyn inbound_parse_api::InboundParseApi;
fn inbox_api(&self) -> &dyn inbox_api::InboxApi;
fn integrations_api(&self) -> &dyn integrations_api::IntegrationsApi;
fn layouts_api(&self) -> &dyn layouts_api::LayoutsApi;
fn messages_api(&self) -> &dyn messages_api::MessagesApi;
fn metrics_api(&self) -> &dyn metrics_api::MetricsApi;
fn notification_groups_api(&self) -> &dyn notification_groups_api::NotificationGroupsApi;
fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi;
fn preferences_api(&self) -> &dyn preferences_api::PreferencesApi;
fn projects_api(&self) -> &dyn projects_api::ProjectsApi;
fn subscriber_credentials_api(&self) -> &dyn subscriber_credentials_api::SubscriberCredentialsApi;
fn subscribers_api(&self) -> &dyn subscribers_api::SubscribersApi;
fn topics_api(&self) -> &dyn topics_api::TopicsApi;
fn translations_api(&self) -> &dyn translations_api::TranslationsApi;
fn webhooks_api(&self) -> &dyn webhooks_api::WebhooksApi;
fn workflows_api(&self) -> &dyn workflows_api::WorkflowsApi;
}
pub struct ApiClient {
activity_api: Box<dyn activity_api::ActivityApi>,
billing_api: Box<dyn billing_api::BillingApi>,
channel_connections_api: Box<dyn channel_connections_api::ChannelConnectionsApi>,
channel_endpoints_api: Box<dyn channel_endpoints_api::ChannelEndpointsApi>,
contexts_api: Box<dyn contexts_api::ContextsApi>,
events_api: Box<dyn events_api::EventsApi>,
feature_flags_api: Box<dyn feature_flags_api::FeatureFlagsApi>,
health_api: Box<dyn health_api::HealthApi>,
inbound_parse_api: Box<dyn inbound_parse_api::InboundParseApi>,
inbox_api: Box<dyn inbox_api::InboxApi>,
integrations_api: Box<dyn integrations_api::IntegrationsApi>,
layouts_api: Box<dyn layouts_api::LayoutsApi>,
messages_api: Box<dyn messages_api::MessagesApi>,
metrics_api: Box<dyn metrics_api::MetricsApi>,
notification_groups_api: Box<dyn notification_groups_api::NotificationGroupsApi>,
notifications_api: Box<dyn notifications_api::NotificationsApi>,
preferences_api: Box<dyn preferences_api::PreferencesApi>,
projects_api: Box<dyn projects_api::ProjectsApi>,
subscriber_credentials_api: Box<dyn subscriber_credentials_api::SubscriberCredentialsApi>,
subscribers_api: Box<dyn subscribers_api::SubscribersApi>,
topics_api: Box<dyn topics_api::TopicsApi>,
translations_api: Box<dyn translations_api::TranslationsApi>,
webhooks_api: Box<dyn webhooks_api::WebhooksApi>,
workflows_api: Box<dyn workflows_api::WorkflowsApi>,
}
impl ApiClient {
pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
Self {
activity_api: Box::new(activity_api::ActivityApiClient::new(configuration.clone())),
billing_api: Box::new(billing_api::BillingApiClient::new(configuration.clone())),
channel_connections_api: Box::new(channel_connections_api::ChannelConnectionsApiClient::new(configuration.clone())),
channel_endpoints_api: Box::new(channel_endpoints_api::ChannelEndpointsApiClient::new(configuration.clone())),
contexts_api: Box::new(contexts_api::ContextsApiClient::new(configuration.clone())),
events_api: Box::new(events_api::EventsApiClient::new(configuration.clone())),
feature_flags_api: Box::new(feature_flags_api::FeatureFlagsApiClient::new(configuration.clone())),
health_api: Box::new(health_api::HealthApiClient::new(configuration.clone())),
inbound_parse_api: Box::new(inbound_parse_api::InboundParseApiClient::new(configuration.clone())),
inbox_api: Box::new(inbox_api::InboxApiClient::new(configuration.clone())),
integrations_api: Box::new(integrations_api::IntegrationsApiClient::new(configuration.clone())),
layouts_api: Box::new(layouts_api::LayoutsApiClient::new(configuration.clone())),
messages_api: Box::new(messages_api::MessagesApiClient::new(configuration.clone())),
metrics_api: Box::new(metrics_api::MetricsApiClient::new(configuration.clone())),
notification_groups_api: Box::new(notification_groups_api::NotificationGroupsApiClient::new(configuration.clone())),
notifications_api: Box::new(notifications_api::NotificationsApiClient::new(configuration.clone())),
preferences_api: Box::new(preferences_api::PreferencesApiClient::new(configuration.clone())),
projects_api: Box::new(projects_api::ProjectsApiClient::new(configuration.clone())),
subscriber_credentials_api: Box::new(subscriber_credentials_api::SubscriberCredentialsApiClient::new(configuration.clone())),
subscribers_api: Box::new(subscribers_api::SubscribersApiClient::new(configuration.clone())),
topics_api: Box::new(topics_api::TopicsApiClient::new(configuration.clone())),
translations_api: Box::new(translations_api::TranslationsApiClient::new(configuration.clone())),
webhooks_api: Box::new(webhooks_api::WebhooksApiClient::new(configuration.clone())),
workflows_api: Box::new(workflows_api::WorkflowsApiClient::new(configuration.clone())),
}
}
}
impl Api for ApiClient {
fn activity_api(&self) -> &dyn activity_api::ActivityApi {
self.activity_api.as_ref()
}
fn billing_api(&self) -> &dyn billing_api::BillingApi {
self.billing_api.as_ref()
}
fn channel_connections_api(&self) -> &dyn channel_connections_api::ChannelConnectionsApi {
self.channel_connections_api.as_ref()
}
fn channel_endpoints_api(&self) -> &dyn channel_endpoints_api::ChannelEndpointsApi {
self.channel_endpoints_api.as_ref()
}
fn contexts_api(&self) -> &dyn contexts_api::ContextsApi {
self.contexts_api.as_ref()
}
fn events_api(&self) -> &dyn events_api::EventsApi {
self.events_api.as_ref()
}
fn feature_flags_api(&self) -> &dyn feature_flags_api::FeatureFlagsApi {
self.feature_flags_api.as_ref()
}
fn health_api(&self) -> &dyn health_api::HealthApi {
self.health_api.as_ref()
}
fn inbound_parse_api(&self) -> &dyn inbound_parse_api::InboundParseApi {
self.inbound_parse_api.as_ref()
}
fn inbox_api(&self) -> &dyn inbox_api::InboxApi {
self.inbox_api.as_ref()
}
fn integrations_api(&self) -> &dyn integrations_api::IntegrationsApi {
self.integrations_api.as_ref()
}
fn layouts_api(&self) -> &dyn layouts_api::LayoutsApi {
self.layouts_api.as_ref()
}
fn messages_api(&self) -> &dyn messages_api::MessagesApi {
self.messages_api.as_ref()
}
fn metrics_api(&self) -> &dyn metrics_api::MetricsApi {
self.metrics_api.as_ref()
}
fn notification_groups_api(&self) -> &dyn notification_groups_api::NotificationGroupsApi {
self.notification_groups_api.as_ref()
}
fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi {
self.notifications_api.as_ref()
}
fn preferences_api(&self) -> &dyn preferences_api::PreferencesApi {
self.preferences_api.as_ref()
}
fn projects_api(&self) -> &dyn projects_api::ProjectsApi {
self.projects_api.as_ref()
}
fn subscriber_credentials_api(&self) -> &dyn subscriber_credentials_api::SubscriberCredentialsApi {
self.subscriber_credentials_api.as_ref()
}
fn subscribers_api(&self) -> &dyn subscribers_api::SubscribersApi {
self.subscribers_api.as_ref()
}
fn topics_api(&self) -> &dyn topics_api::TopicsApi {
self.topics_api.as_ref()
}
fn translations_api(&self) -> &dyn translations_api::TranslationsApi {
self.translations_api.as_ref()
}
fn webhooks_api(&self) -> &dyn webhooks_api::WebhooksApi {
self.webhooks_api.as_ref()
}
fn workflows_api(&self) -> &dyn workflows_api::WorkflowsApi {
self.workflows_api.as_ref()
}
}
#[cfg(feature = "mockall")]
pub struct MockApiClient {
pub activity_api_mock: activity_api::MockActivityApi,
pub billing_api_mock: billing_api::MockBillingApi,
pub channel_connections_api_mock: channel_connections_api::MockChannelConnectionsApi,
pub channel_endpoints_api_mock: channel_endpoints_api::MockChannelEndpointsApi,
pub contexts_api_mock: contexts_api::MockContextsApi,
pub events_api_mock: events_api::MockEventsApi,
pub feature_flags_api_mock: feature_flags_api::MockFeatureFlagsApi,
pub health_api_mock: health_api::MockHealthApi,
pub inbound_parse_api_mock: inbound_parse_api::MockInboundParseApi,
pub inbox_api_mock: inbox_api::MockInboxApi,
pub integrations_api_mock: integrations_api::MockIntegrationsApi,
pub layouts_api_mock: layouts_api::MockLayoutsApi,
pub messages_api_mock: messages_api::MockMessagesApi,
pub metrics_api_mock: metrics_api::MockMetricsApi,
pub notification_groups_api_mock: notification_groups_api::MockNotificationGroupsApi,
pub notifications_api_mock: notifications_api::MockNotificationsApi,
pub preferences_api_mock: preferences_api::MockPreferencesApi,
pub projects_api_mock: projects_api::MockProjectsApi,
pub subscriber_credentials_api_mock: subscriber_credentials_api::MockSubscriberCredentialsApi,
pub subscribers_api_mock: subscribers_api::MockSubscribersApi,
pub topics_api_mock: topics_api::MockTopicsApi,
pub translations_api_mock: translations_api::MockTranslationsApi,
pub webhooks_api_mock: webhooks_api::MockWebhooksApi,
pub workflows_api_mock: workflows_api::MockWorkflowsApi,
}
#[cfg(feature = "mockall")]
impl MockApiClient {
pub fn new() -> Self {
Self {
activity_api_mock: activity_api::MockActivityApi::new(),
billing_api_mock: billing_api::MockBillingApi::new(),
channel_connections_api_mock: channel_connections_api::MockChannelConnectionsApi::new(),
channel_endpoints_api_mock: channel_endpoints_api::MockChannelEndpointsApi::new(),
contexts_api_mock: contexts_api::MockContextsApi::new(),
events_api_mock: events_api::MockEventsApi::new(),
feature_flags_api_mock: feature_flags_api::MockFeatureFlagsApi::new(),
health_api_mock: health_api::MockHealthApi::new(),
inbound_parse_api_mock: inbound_parse_api::MockInboundParseApi::new(),
inbox_api_mock: inbox_api::MockInboxApi::new(),
integrations_api_mock: integrations_api::MockIntegrationsApi::new(),
layouts_api_mock: layouts_api::MockLayoutsApi::new(),
messages_api_mock: messages_api::MockMessagesApi::new(),
metrics_api_mock: metrics_api::MockMetricsApi::new(),
notification_groups_api_mock: notification_groups_api::MockNotificationGroupsApi::new(),
notifications_api_mock: notifications_api::MockNotificationsApi::new(),
preferences_api_mock: preferences_api::MockPreferencesApi::new(),
projects_api_mock: projects_api::MockProjectsApi::new(),
subscriber_credentials_api_mock: subscriber_credentials_api::MockSubscriberCredentialsApi::new(),
subscribers_api_mock: subscribers_api::MockSubscribersApi::new(),
topics_api_mock: topics_api::MockTopicsApi::new(),
translations_api_mock: translations_api::MockTranslationsApi::new(),
webhooks_api_mock: webhooks_api::MockWebhooksApi::new(),
workflows_api_mock: workflows_api::MockWorkflowsApi::new(),
}
}
}
#[cfg(feature = "mockall")]
impl Api for MockApiClient {
fn activity_api(&self) -> &dyn activity_api::ActivityApi {
&self.activity_api_mock
}
fn billing_api(&self) -> &dyn billing_api::BillingApi {
&self.billing_api_mock
}
fn channel_connections_api(&self) -> &dyn channel_connections_api::ChannelConnectionsApi {
&self.channel_connections_api_mock
}
fn channel_endpoints_api(&self) -> &dyn channel_endpoints_api::ChannelEndpointsApi {
&self.channel_endpoints_api_mock
}
fn contexts_api(&self) -> &dyn contexts_api::ContextsApi {
&self.contexts_api_mock
}
fn events_api(&self) -> &dyn events_api::EventsApi {
&self.events_api_mock
}
fn feature_flags_api(&self) -> &dyn feature_flags_api::FeatureFlagsApi {
&self.feature_flags_api_mock
}
fn health_api(&self) -> &dyn health_api::HealthApi {
&self.health_api_mock
}
fn inbound_parse_api(&self) -> &dyn inbound_parse_api::InboundParseApi {
&self.inbound_parse_api_mock
}
fn inbox_api(&self) -> &dyn inbox_api::InboxApi {
&self.inbox_api_mock
}
fn integrations_api(&self) -> &dyn integrations_api::IntegrationsApi {
&self.integrations_api_mock
}
fn layouts_api(&self) -> &dyn layouts_api::LayoutsApi {
&self.layouts_api_mock
}
fn messages_api(&self) -> &dyn messages_api::MessagesApi {
&self.messages_api_mock
}
fn metrics_api(&self) -> &dyn metrics_api::MetricsApi {
&self.metrics_api_mock
}
fn notification_groups_api(&self) -> &dyn notification_groups_api::NotificationGroupsApi {
&self.notification_groups_api_mock
}
fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi {
&self.notifications_api_mock
}
fn preferences_api(&self) -> &dyn preferences_api::PreferencesApi {
&self.preferences_api_mock
}
fn projects_api(&self) -> &dyn projects_api::ProjectsApi {
&self.projects_api_mock
}
fn subscriber_credentials_api(&self) -> &dyn subscriber_credentials_api::SubscriberCredentialsApi {
&self.subscriber_credentials_api_mock
}
fn subscribers_api(&self) -> &dyn subscribers_api::SubscribersApi {
&self.subscribers_api_mock
}
fn topics_api(&self) -> &dyn topics_api::TopicsApi {
&self.topics_api_mock
}
fn translations_api(&self) -> &dyn translations_api::TranslationsApi {
&self.translations_api_mock
}
fn webhooks_api(&self) -> &dyn webhooks_api::WebhooksApi {
&self.webhooks_api_mock
}
fn workflows_api(&self) -> &dyn workflows_api::WorkflowsApi {
&self.workflows_api_mock
}
}