#![allow(clippy::large_enum_variant)]
#![allow(clippy::format_in_format_args)]
#![allow(clippy::let_unit_value)]
#![allow(unreachable_patterns)]
use serde::{Deserialize, Serialize};
mod tri_state_serde {
use serde::{Deserialize, Deserializer};
pub fn deserialize<'de, D, T>(de: D) -> Result<Option<T>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
T::deserialize(de).map(Some)
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MarketStatsResponse {
pub data: Vec<MarketStatsItem>,
pub meta: MarketStatsResponseMeta,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MarketStatsResponseMeta {
pub count: i64,
#[serde(rename = "exchangeMic")]
pub exchange_mic: String,
#[serde(rename = "tradingDate")]
pub trading_date: chrono::NaiveDate,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MarketStatsItem {
pub change: MarketStatsItemChange,
pub identifier: InstrumentIdentifier,
pub name: Option<String>,
pub price: f64,
pub rank: i64,
pub trades: i64,
pub value: f64,
pub volume: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MarketStatsItemChange {
pub amount: f64,
pub direction: MarketStatsItemChangeDirection,
pub percent: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum MarketStatsItemChangeDirection {
#[default]
#[serde(rename = "up")]
Up,
#[serde(rename = "down")]
Down,
}
impl MarketStatsItemChangeDirection {
pub fn as_str(&self) -> &'static str {
match self {
Self::Up => "up",
Self::Down => "down",
}
}
}
impl ::std::fmt::Display for MarketStatsItemChangeDirection {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for MarketStatsItemChangeDirection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct InstrumentIdentifier {
pub isin: String,
pub mic: String,
pub symbol: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ListRnsDisclosureItemsResponse {
pub data: Vec<DisclosureItem>,
pub meta: Meta,
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct ListExchangesResponse {
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<Vec<ExchangeListItem>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub meta: Option<Meta>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ExchangeListItem {
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub city: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub comments: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub country: Option<Option<String>>,
pub mic: String,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub name: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub status: Option<Option<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTradesResponse {
pub data: Vec<TradeItem>,
pub meta: Meta,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TradeItem {
pub price: f64,
#[serde(rename = "quoteCondition")]
pub quote_condition: Option<String>,
pub side: String,
pub timestamp: chrono::DateTime<chrono::Utc>,
pub venue: Option<TradeItemVenue>,
pub volume: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TradeItemVenue {
#[default]
#[serde(rename = "Exchange")]
Exchange,
#[serde(rename = "Off-book")]
OffBook,
}
impl TradeItemVenue {
pub fn as_str(&self) -> &'static str {
match self {
Self::Exchange => "Exchange",
Self::OffBook => "Off-book",
}
}
}
impl ::std::fmt::Display for TradeItemVenue {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for TradeItemVenue {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetTimeseriesResponseDataVariant2 {
#[serde(flatten)]
pub additional_properties: std::collections::BTreeMap<String, TimeseriesItemKeyed>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTimeseriesResponse {
pub data: GetTimeseriesResponseData,
pub meta: Meta,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TimeseriesItemKeyed {
pub close: f64,
pub high: f64,
pub low: f64,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub nav: Option<Option<f64>>,
pub open: f64,
pub volume: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TimeseriesItem {
pub close: f64,
pub date: chrono::NaiveDate,
pub high: f64,
pub low: f64,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub nav: Option<Option<f64>>,
pub open: f64,
pub volume: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Meta {
pub paging: Paging,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum GetTimeseriesResponseData {
TimeseriesArray(Vec<TimeseriesItem>),
GetTimeseriesResponseDataVariant2(GetTimeseriesResponseDataVariant2),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetRnsDisclosureItemResponse {
pub data: DisclosureItem,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetNavResponse {
pub data: Vec<NavItem>,
pub meta: GetNavResponseMeta,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetNavResponseMeta {
pub paging: Paging,
}
#[derive(Debug, Clone)]
pub enum Paging {
CursorPaging(CursorPaging),
ClassicPaging(ClassicPaging),
}
impl Serialize for Paging {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match self {
Self::CursorPaging(value) => serde::Serialize::serialize(value, serializer),
Self::ClassicPaging(value) => serde::Serialize::serialize(value, serializer),
}
}
}
impl<'de> Deserialize<'de> for Paging {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
fn exact_json_integer(number: &serde_json::Number) -> Option<i128> {
number.as_i64().map(i128::from).or_else(|| number.as_u64().map(i128::from))
}
fn json_numbers_have_same_value(
encoded: &serde_json::Number,
input: &serde_json::Number,
) -> bool {
match (exact_json_integer(encoded), exact_json_integer(input)) {
(Some(encoded), Some(input)) => encoded == input,
(Some(encoded), None) => {
input
.as_f64()
.is_some_and(|input| {
input.is_finite() && input.fract() == 0.0
&& input as i128 == encoded
})
}
(None, Some(input)) => {
encoded
.as_f64()
.is_some_and(|encoded| {
encoded.is_finite() && encoded.fract() == 0.0
&& encoded as i128 == input
})
}
(None, None) => encoded.as_f64() == input.as_f64(),
}
}
fn preserves_complete_json_input(
encoded: &serde_json::Value,
input: &serde_json::Value,
nulls_may_be_absent: bool,
encoded_keys_may_be_extra: bool,
) -> bool {
match (encoded, input) {
(
serde_json::Value::Object(encoded),
serde_json::Value::Object(input),
) => {
(encoded_keys_may_be_extra
|| encoded.keys().all(|key| input.contains_key(key)))
&& input
.iter()
.all(|(key, value)| match encoded.get(key) {
Some(encoded_value) => {
preserves_complete_json_input(
encoded_value,
value,
nulls_may_be_absent,
encoded_keys_may_be_extra,
)
}
None => nulls_may_be_absent && value.is_null(),
})
}
(serde_json::Value::Array(encoded), serde_json::Value::Array(input)) => {
encoded.len() == input.len()
&& encoded
.iter()
.zip(input)
.all(|(encoded, input)| {
preserves_complete_json_input(
encoded,
input,
nulls_may_be_absent,
encoded_keys_may_be_extra,
)
})
}
(
serde_json::Value::Number(encoded),
serde_json::Value::Number(input),
) => json_numbers_have_same_value(encoded, input),
_ => encoded == input,
}
}
let input = <serde_json::Value as Deserialize>::deserialize(deserializer)?;
let mut matched = None;
let mut equivalent = None;
let mut equivalent_matches = 0usize;
if true {
if let Ok(candidate) = serde_json::from_value::<
CursorPaging,
>(input.clone()) {
match serde_json::to_value(&candidate) {
Ok(encoded) if encoded == input => {
if matched.is_some() {
return Err(
serde::de::Error::custom(
concat!(
"ambiguous oneOf value for ", stringify!(Paging),
": more than one branch preserved the complete input",
),
),
);
}
matched = Some(Self::CursorPaging(candidate));
}
Ok(
encoded,
) if preserves_complete_json_input(
&encoded,
&input,
true,
false,
) => {
equivalent_matches += 1;
equivalent.get_or_insert(Self::CursorPaging(candidate));
}
_ => {}
}
}
}
if true {
if let Ok(candidate) = serde_json::from_value::<
ClassicPaging,
>(input.clone()) {
match serde_json::to_value(&candidate) {
Ok(encoded) if encoded == input => {
if matched.is_some() {
return Err(
serde::de::Error::custom(
concat!(
"ambiguous oneOf value for ", stringify!(Paging),
": more than one branch preserved the complete input",
),
),
);
}
matched = Some(Self::ClassicPaging(candidate));
}
Ok(
encoded,
) if preserves_complete_json_input(
&encoded,
&input,
true,
false,
) => {
equivalent_matches += 1;
equivalent.get_or_insert(Self::ClassicPaging(candidate));
}
_ => {}
}
}
}
if let Some(matched) = matched {
return Ok(matched);
}
if equivalent_matches > 1 {
return Err(
serde::de::Error::custom(
concat!(
"ambiguous oneOf value for ", stringify!(Paging),
": more than one branch preserved an equivalent input",
),
),
);
}
equivalent
.ok_or_else(|| serde::de::Error::custom(
concat!(
"no oneOf branch for ", stringify!(Paging),
" preserved the complete input",
),
))
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CursorPaging {
#[serde(
rename = "latestCursor",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub latest_cursor: Option<Option<String>>,
#[serde(rename = "nextCursor")]
pub next_cursor: Option<String>,
#[serde(rename = "pageSize")]
pub page_size: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ClassicPaging {
#[serde(rename = "itemTotal")]
pub item_total: i64,
#[serde(rename = "pageNumber")]
pub page_number: i64,
#[serde(rename = "pageSize")]
pub page_size: i64,
#[serde(rename = "pageTotal")]
pub page_total: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NavItem {
pub date: chrono::NaiveDate,
pub values: Vec<NavItemValuesItem>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NavItemValuesItem {
pub currency: String,
pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetExchangeResponse {
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<ExchangeDetail>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetCurrentPriceResponse {
pub data: PriceSnapshot,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshot {
#[serde(skip_serializing_if = "Option::is_none")]
pub fundamentals: Option<PriceSnapshotFundamentals>,
#[serde(skip_serializing_if = "Option::is_none")]
pub identifier: Option<PriceSnapshotIdentifier>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quote: Option<PriceSnapshotQuote>,
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<PriceSnapshotSession>,
#[serde(skip_serializing_if = "Option::is_none")]
pub year: Option<PriceSnapshotYear>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotYear {
#[serde(skip_serializing_if = "Option::is_none")]
pub high: Option<PriceSnapshotYearHigh>,
#[serde(skip_serializing_if = "Option::is_none")]
pub low: Option<PriceSnapshotYearLow>,
#[serde(skip_serializing_if = "Option::is_none")]
pub performance: Option<PriceSnapshotYearPerformance>,
#[serde(skip_serializing_if = "Option::is_none")]
pub volatility: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub volume: Option<PriceSnapshotYearVolume>,
#[serde(skip_serializing_if = "Option::is_none")]
pub vwap: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotYearVolume {
#[serde(skip_serializing_if = "Option::is_none")]
pub average: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotYearPerformance {
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub percent: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotYearLow {
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<chrono::DateTime<chrono::Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotYearHigh {
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<chrono::DateTime<chrono::Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotSession {
#[serde(skip_serializing_if = "Option::is_none")]
pub close: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<chrono::NaiveDate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub high: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub low: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub open: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub previous: Option<PriceSnapshotSessionPrevious>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trades: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub volume: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub vwap: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotSessionPrevious {
#[serde(skip_serializing_if = "Option::is_none")]
pub close: Option<f64>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub date: Option<Option<chrono::NaiveDate>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub volume: Option<Option<i64>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotQuote {
#[serde(skip_serializing_if = "Option::is_none")]
pub ask: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bid: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub change: Option<PriceSnapshotQuoteChange>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mid: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub spread: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trade: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotQuoteChange {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub basis: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub direction: Option<PriceSnapshotQuoteChangeDirection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub percent: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PriceSnapshotQuoteChangeDirection {
Up,
Down,
Custom(String),
}
impl<'de> serde::Deserialize<'de> for PriceSnapshotQuoteChangeDirection {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
match value.as_str() {
"up" => Ok(PriceSnapshotQuoteChangeDirection::Up),
"down" => Ok(PriceSnapshotQuoteChangeDirection::Down),
_ => Ok(PriceSnapshotQuoteChangeDirection::Custom(value)),
}
}
}
impl serde::Serialize for PriceSnapshotQuoteChangeDirection {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl PriceSnapshotQuoteChangeDirection {
pub fn as_str(&self) -> &str {
match self {
PriceSnapshotQuoteChangeDirection::Up => "up",
PriceSnapshotQuoteChangeDirection::Down => "down",
PriceSnapshotQuoteChangeDirection::Custom(s) => s.as_str(),
}
}
}
impl ::std::fmt::Display for PriceSnapshotQuoteChangeDirection {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for PriceSnapshotQuoteChangeDirection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotIdentifier {
#[serde(skip_serializing_if = "Option::is_none")]
pub isin: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mic: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub symbol: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceSnapshotFundamentals {
#[serde(
rename = "marketCap",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub market_cap: Option<Option<f64>>,
#[serde(
rename = "sharesInIssue",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub shares_in_issue: Option<Option<f64>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ExchangeDetail {
#[serde(rename = "_links")]
pub links: ExchangeDetailLinks,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub abbreviation: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub city: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub comments: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub country: Option<Option<String>>,
#[serde(
rename = "creationDate",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub creation_date: Option<Option<String>>,
#[serde(
rename = "expiryDate",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub expiry_date: Option<Option<String>>,
#[serde(
rename = "lastUpdateDate",
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub last_update_date: Option<Option<String>>,
pub mic: String,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub name: Option<Option<String>>,
pub segments: Vec<ExchangeSegment>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub status: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub website: Option<Option<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ExchangeSegment {
pub mic: String,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub name: Option<Option<String>>,
#[serde(
skip_serializing_if = "Option::is_none",
default,
deserialize_with = "tri_state_serde::deserialize"
)]
pub status: Option<Option<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct ExchangeDetailLinks {
#[serde(rename = "self", skip_serializing_if = "Option::is_none")]
pub self_field: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorResponse {
pub error: ErrorDetail,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorDetail {
#[serde(skip_serializing_if = "Option::is_none")]
pub hint: Option<String>,
pub message: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct DisclosureItem {
pub category: Vec<Category>,
pub guid: String,
pub headline: String,
pub issuer: Company,
pub publication: Vec<Publication>,
#[serde(skip_serializing_if = "Option::is_none")]
pub related: Option<Vec<Company>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub replaces: Option<Replaces>,
#[serde(rename = "rnsId")]
pub rns_id: String,
pub source: String,
pub timestamp: chrono::DateTime<chrono::Utc>,
pub version: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Replaces {
pub guid: String,
pub version: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Publication {
pub mime: String,
pub url: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Company {
#[serde(skip_serializing_if = "Option::is_none")]
pub instrument: Option<Instrument>,
#[serde(skip_serializing_if = "Option::is_none")]
pub lei: Option<String>,
pub name: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Instrument {
pub isin: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub symbol: Option<Symbol>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Symbol {
pub mnemonic: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Category {
pub code: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub importance: Option<CategoryImportance>,
pub kind: CategoryKind,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CategoryKind {
Ticker,
Fca,
Rns,
Custom(String),
}
impl<'de> serde::Deserialize<'de> for CategoryKind {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
match value.as_str() {
"Ticker" => Ok(CategoryKind::Ticker),
"FCA" => Ok(CategoryKind::Fca),
"RNS" => Ok(CategoryKind::Rns),
_ => Ok(CategoryKind::Custom(value)),
}
}
}
impl serde::Serialize for CategoryKind {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl CategoryKind {
pub fn as_str(&self) -> &str {
match self {
CategoryKind::Ticker => "Ticker",
CategoryKind::Fca => "FCA",
CategoryKind::Rns => "RNS",
CategoryKind::Custom(s) => s.as_str(),
}
}
}
impl ::std::fmt::Display for CategoryKind {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for CategoryKind {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CategoryImportance {
Low,
Medium,
High,
Ultra,
Custom(String),
}
impl<'de> serde::Deserialize<'de> for CategoryImportance {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
match value.as_str() {
"low" => Ok(CategoryImportance::Low),
"medium" => Ok(CategoryImportance::Medium),
"high" => Ok(CategoryImportance::High),
"ultra" => Ok(CategoryImportance::Ultra),
_ => Ok(CategoryImportance::Custom(value)),
}
}
}
impl serde::Serialize for CategoryImportance {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl CategoryImportance {
pub fn as_str(&self) -> &str {
match self {
CategoryImportance::Low => "low",
CategoryImportance::Medium => "medium",
CategoryImportance::High => "high",
CategoryImportance::Ultra => "ultra",
CategoryImportance::Custom(s) => s.as_str(),
}
}
}
impl ::std::fmt::Display for CategoryImportance {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for CategoryImportance {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct HealthResponse {
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
}