#![allow(unused_imports)]
use std::sync::Arc;
use std::borrow::Borrow;
use std::borrow::Cow;
use std::collections::HashMap;
use hyper;
use serde_json;
use tokio::runtime::Runtime;
use futures;
use futures::{Future, Stream};
use bigdecimal::BigDecimal;
use hyper::Body;
use hyper::body::Bytes;
use hyper::body::HttpBody;
use std::str::FromStr;
use chrono::{NaiveDateTime, DateTime, FixedOffset, Utc, SecondsFormat};
use crate::OutlinePrint;
use crate::models::*;
use super::{Error, configuration};
use headers::{Authorization, Header};
use headers::authorization::Credentials;
pub struct ReferenceApiClient<C: hyper::client::connect::Connect + Clone + Send + Sync> {
configuration: Arc<configuration::Configuration<C>>,
}
impl<C: hyper::client::connect::Connect + Clone + Send + Sync + 'static> ReferenceApiClient<C> {
pub fn new(configuration: Arc<configuration::Configuration<C>>) -> ReferenceApiClient<C> {
ReferenceApiClient {
configuration: configuration,
}
}
}
#[async_trait::async_trait]
pub trait ReferenceApi {
async fn v1_marketstatus_now_get(&self, ) -> Result<MarketStatus, Error<serde_json::Value>>;
async fn v1_marketstatus_upcoming_get(&self, ) -> Result<Vec<MarketHoliday>, Error<serde_json::Value>>;
async fn v1_meta_symbols_symbol_company_get(&self, symbol: &str) -> Result<Company, Error<serde_json::Value>>;
async fn v1_meta_symbols_symbol_news_get(&self, symbol: &str, perpage: i64, page: i64) -> Result<Vec<News>, Error<serde_json::Value>>;
async fn v2_reference_dividends_symbol_get(&self, symbol: &str) -> Result<InlineResponse2005, Error<serde_json::Value>>;
async fn v2_reference_financials_symbol_get(&self, symbol: &str, limit: i64, _type: &str, sort: &str) -> Result<InlineResponse2006, Error<serde_json::Value>>;
async fn v2_reference_locales_get(&self, ) -> Result<InlineResponse2003, Error<serde_json::Value>>;
async fn v2_reference_markets_get(&self, ) -> Result<InlineResponse2002, Error<serde_json::Value>>;
async fn v2_reference_splits_symbol_get(&self, symbol: &str) -> Result<InlineResponse2004, Error<serde_json::Value>>;
async fn v2_reference_tickers_get(&self, sort: &str, _type: &str, market: &str, locale: &str, search: &str, perpage: i64, page: i64, active: bool) -> Result<InlineResponse200, Error<serde_json::Value>>;
async fn v2_reference_types_get(&self, ) -> Result<InlineResponse2001, Error<serde_json::Value>>;
}
#[async_trait::async_trait]
impl<C: hyper::client::connect::Connect + Clone + Send + Sync + 'static>ReferenceApi for ReferenceApiClient<C> {
async fn v1_marketstatus_now_get(&self, ) -> Result<MarketStatus, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v1/marketstatus/now?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v1_marketstatus_upcoming_get(&self, ) -> Result<Vec<MarketHoliday>, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v1/marketstatus/upcoming?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v1_meta_symbols_symbol_company_get(&self, symbol: &str) -> Result<Company, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v1/meta/symbols/{symbol}/company?{}", configuration.base_path, query_string, symbol=symbol);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v1_meta_symbols_symbol_news_get(&self, symbol: &str, perpage: i64, page: i64) -> Result<Vec<News>, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
query.append_pair("perpage", &perpage.outline_print() );
query.append_pair("page", &page.outline_print() );
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v1/meta/symbols/{symbol}/news?{}", configuration.base_path, query_string, symbol=symbol);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_dividends_symbol_get(&self, symbol: &str) -> Result<InlineResponse2005, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/dividends/{symbol}?{}", configuration.base_path, query_string, symbol=symbol);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_financials_symbol_get(&self, symbol: &str, limit: i64, _type: &str, sort: &str) -> Result<InlineResponse2006, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
query.append_pair("limit", &limit.outline_print() );
query.append_pair("type", &_type.outline_print() );
query.append_pair("sort", &sort.outline_print() );
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/financials/{symbol}?{}", configuration.base_path, query_string, symbol=symbol);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_locales_get(&self, ) -> Result<InlineResponse2003, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/locales?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_markets_get(&self, ) -> Result<InlineResponse2002, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/markets?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_splits_symbol_get(&self, symbol: &str) -> Result<InlineResponse2004, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/splits/{symbol}?{}", configuration.base_path, query_string, symbol=symbol);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_tickers_get(&self, sort: &str, _type: &str, market: &str, locale: &str, search: &str, perpage: i64, page: i64, active: bool) -> Result<InlineResponse200, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
query.append_pair("sort", &sort.outline_print() );
query.append_pair("type", &_type.outline_print() );
query.append_pair("market", &market.outline_print() );
query.append_pair("locale", &locale.outline_print() );
query.append_pair("search", &search.outline_print() );
query.append_pair("perpage", &perpage.outline_print() );
query.append_pair("page", &page.outline_print() );
query.append_pair("active", &active.outline_print() );
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/tickers?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
async fn v2_reference_types_get(&self, ) -> Result<InlineResponse2001, Error<serde_json::Value>> {
let configuration: &configuration::Configuration<C> = self.configuration.borrow();
let mut auth_headers = HashMap::<String, String>::new();
let mut auth_query = HashMap::<String, String>::new();
if let Some(ref apikey) = configuration.api_key {
let key = apikey.key.clone();
let val = match apikey.prefix {
Some(ref prefix) => format!("{} {}", prefix, key),
None => key,
};
auth_query.insert("apiKey".to_owned(), val);
};
let method = hyper::Method::GET;
let query_string = {
let mut query = ::url::form_urlencoded::Serializer::new(String::new());
for (key, val) in &auth_query {
query.append_pair(key, val);
}
query.finish()
};
let uri_str = format!("{}v2/reference/types?{}", configuration.base_path, query_string);
let uri: hyper::Uri = uri_str.parse().unwrap();
let mut req =
hyper::Request::builder()
.method(method)
.uri(uri);
let headers = req.headers_mut().unwrap();
if let Some(ref user_agent) = configuration.user_agent {
headers.insert(hyper::header::USER_AGENT, user_agent.parse().unwrap());
}
for (key, val) in auth_headers {
headers.insert(
hyper::header::HeaderName::from_str(key.as_ref()).unwrap(),
val.parse().unwrap(),
);
}
let somebody = Body::empty();
let req = req.body(somebody).unwrap();
let res = configuration
.client.request(req)
.await
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
let mut res = res?;
let status = res.status();
let mut res_body: Vec<u8> = vec![];
while let Some(chunk) = res.body_mut().data().await {
let mut chunk_vec = chunk.unwrap().to_vec();
res_body.append(chunk_vec.as_mut());
}
let res_body =
if status.is_success() {
Ok(res_body)
} else {
Err(Error::from((status, res_body.borrow())))
};
let mut res_body = res_body?;
let res_body =
serde_json::from_slice(res_body.borrow())
.map_err(|e| -> Error<serde_json::Value> { Error::from(e) });
res_body
}
}