1#![allow(missing_docs)]
2
3use rust_decimal::Decimal;
4use serde::{Deserialize, Serialize};
5use strum_macros::{Display, EnumString};
6use time::OffsetDateTime;
7
8use crate::utils::counter::deserialize_counter_id_as_symbol;
9
10#[derive(Debug, Clone, Serialize, Deserialize)]
18pub struct FinancialReports {
19 pub list: serde_json::Value,
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
29pub struct DividendList {
30 pub list: Vec<DividendItem>,
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36pub struct DividendItem {
37 #[serde(
39 rename = "counter_id",
40 deserialize_with = "deserialize_counter_id_as_symbol"
41 )]
42 pub symbol: String,
43 #[serde(default)]
45 pub id: String,
46 pub desc: String,
48 pub record_date: String,
50 pub ex_date: String,
52 pub payment_date: String,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct InstitutionRating {
62 pub latest: InstitutionRatingLatest,
64 pub summary: InstitutionRatingSummary,
66}
67
68#[derive(Debug, Clone, Serialize, Deserialize)]
70pub struct InstitutionRatingLatest {
71 pub evaluate: RatingEvaluate,
73 pub target: RatingTarget,
75 pub industry_id: i64,
77 pub industry_name: String,
79 pub industry_rank: i32,
81 pub industry_total: i32,
83 pub industry_mean: i32,
85 pub industry_median: i32,
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
91pub struct RatingEvaluate {
92 pub buy: i32,
94 pub over: i32,
96 pub hold: i32,
98 pub under: i32,
100 pub sell: i32,
102 pub no_opinion: i32,
104 pub total: i32,
106 pub start_date: String,
108 pub end_date: String,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize)]
114pub struct RatingTarget {
115 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
117 pub highest_price: Option<Decimal>,
118 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
120 pub lowest_price: Option<Decimal>,
121 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
123 pub prev_close: Option<Decimal>,
124 pub start_date: String,
126 pub end_date: String,
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct InstitutionRatingSummary {
133 pub ccy_symbol: String,
135 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
137 pub change: Option<Decimal>,
138 pub evaluate: RatingSummaryEvaluate,
140 pub recommend: InstitutionRecommend,
142 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
144 pub target: Option<Decimal>,
145 pub updated_at: String,
147}
148
149#[derive(Debug, Clone, Serialize, Deserialize)]
151pub struct RatingSummaryEvaluate {
152 pub buy: i32,
154 pub date: String,
156 pub hold: i32,
158 pub sell: i32,
160 pub strong_buy: i32,
162 pub under: i32,
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
170pub struct InstitutionRatingDetail {
171 pub ccy_symbol: String,
173 pub evaluate: InstitutionRatingDetailEvaluate,
175 pub target: InstitutionRatingDetailTarget,
177}
178
179#[derive(Debug, Clone, Serialize, Deserialize)]
181pub struct InstitutionRatingDetailEvaluate {
182 pub list: Vec<InstitutionRatingDetailEvaluateItem>,
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
188pub struct InstitutionRatingDetailEvaluateItem {
189 pub buy: i32,
191 pub date: String,
193 pub hold: i32,
195 pub sell: i32,
197 #[serde(default)]
199 pub strong_buy: i32,
200 #[serde(default)]
202 pub no_opinion: i32,
203 pub under: i32,
205}
206
207#[derive(Debug, Clone, Serialize, Deserialize)]
209pub struct InstitutionRatingDetailTarget {
210 pub data_percent: Option<Decimal>,
212 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
214 pub prediction_accuracy: Option<Decimal>,
215 pub updated_at: String,
217 pub list: Vec<InstitutionRatingDetailTargetItem>,
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize)]
223pub struct InstitutionRatingDetailTargetItem {
224 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
226 pub avg_target: Option<Decimal>,
227 pub date: String,
229 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
231 pub max_target: Option<Decimal>,
232 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
234 pub min_target: Option<Decimal>,
235 pub meet: bool,
237 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
239 pub price: Option<Decimal>,
240 pub timestamp: String,
242}
243
244#[derive(Debug, Clone, Serialize, Deserialize)]
248pub struct ForecastEps {
249 pub items: Vec<ForecastEpsItem>,
251}
252
253#[derive(Debug, Clone, Serialize, Deserialize)]
255pub struct ForecastEpsItem {
256 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
258 pub forecast_eps_median: Option<Decimal>,
259 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
261 pub forecast_eps_mean: Option<Decimal>,
262 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
264 pub forecast_eps_lowest: Option<Decimal>,
265 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
267 pub forecast_eps_highest: Option<Decimal>,
268 pub institution_total: i32,
270 pub institution_up: i32,
272 pub institution_down: i32,
274 #[serde(deserialize_with = "crate::serde_utils::deserialize_timestamp")]
276 pub forecast_start_date: OffsetDateTime,
277 #[serde(deserialize_with = "crate::serde_utils::deserialize_timestamp")]
279 pub forecast_end_date: OffsetDateTime,
280}
281
282#[derive(Debug, Clone, Serialize, Deserialize)]
286pub struct FinancialConsensus {
287 pub list: Vec<ConsensusReport>,
289 pub current_index: i32,
291 pub currency: String,
293 #[serde(default)]
295 pub opt_periods: Vec<String>,
296 pub current_period: String,
298}
299
300#[derive(Debug, Clone, Serialize, Deserialize)]
302pub struct ConsensusReport {
303 pub fiscal_year: i32,
305 pub fiscal_period: String,
307 pub period_text: String,
309 pub details: Vec<ConsensusDetail>,
311}
312
313#[derive(Debug, Clone, Serialize, Deserialize)]
315pub struct ConsensusDetail {
316 pub key: String,
318 pub name: String,
320 pub description: String,
322 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
324 pub actual: Option<Decimal>,
325 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
327 pub estimate: Option<Decimal>,
328 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
330 pub comp_value: Option<Decimal>,
331 pub comp_desc: String,
333 pub comp: String,
335 pub is_released: bool,
337}
338
339#[derive(Debug, Clone, Serialize, Deserialize)]
343pub struct ValuationData {
344 pub metrics: ValuationMetricsData,
346}
347
348#[derive(Debug, Clone, Serialize, Deserialize)]
350pub struct ValuationMetricsData {
351 pub pe: Option<ValuationMetricData>,
353 pub pb: Option<ValuationMetricData>,
355 pub ps: Option<ValuationMetricData>,
357 pub dvd_yld: Option<ValuationMetricData>,
359}
360
361#[derive(Debug, Clone, Serialize, Deserialize)]
363pub struct ValuationMetricData {
364 pub desc: String,
366 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
368 pub high: Option<Decimal>,
369 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
371 pub low: Option<Decimal>,
372 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
374 pub median: Option<Decimal>,
375 pub list: Vec<ValuationPoint>,
377}
378
379#[derive(Debug, Clone, Serialize, Deserialize)]
381pub struct ValuationPoint {
382 #[serde(deserialize_with = "crate::serde_utils::deserialize_timestamp")]
384 pub timestamp: OffsetDateTime,
385 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
387 pub value: Option<Decimal>,
388}
389
390#[derive(Debug, Clone, Serialize, Deserialize)]
394pub struct ValuationHistoryResponse {
395 pub history: ValuationHistoryData,
397}
398
399#[derive(Debug, Clone, Serialize, Deserialize)]
401pub struct ValuationHistoryData {
402 pub metrics: ValuationHistoryMetrics,
404}
405
406#[derive(Debug, Clone, Serialize, Deserialize)]
408pub struct ValuationHistoryMetrics {
409 pub pe: Option<ValuationHistoryMetric>,
411 pub pb: Option<ValuationHistoryMetric>,
413 pub ps: Option<ValuationHistoryMetric>,
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize)]
419pub struct ValuationHistoryMetric {
420 pub desc: String,
422 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
424 pub high: Option<Decimal>,
425 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
427 pub low: Option<Decimal>,
428 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
430 pub median: Option<Decimal>,
431 pub list: Vec<ValuationPoint>,
433}
434
435#[derive(Debug, Clone, Serialize, Deserialize)]
439pub struct IndustryValuationList {
440 pub list: Vec<IndustryValuationItem>,
442}
443
444#[derive(Debug, Clone, Serialize, Deserialize)]
446pub struct IndustryValuationItem {
447 #[serde(
449 rename = "counter_id",
450 deserialize_with = "deserialize_counter_id_as_symbol"
451 )]
452 pub symbol: String,
453 pub name: String,
455 pub currency: String,
457 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
459 pub assets: Option<Decimal>,
460 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
462 pub bps: Option<Decimal>,
463 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
465 pub eps: Option<Decimal>,
466 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
468 pub dps: Option<Decimal>,
469 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
471 pub div_yld: Option<Decimal>,
472 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
474 pub div_payout_ratio: Option<Decimal>,
475 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
477 pub five_y_avg_dps: Option<Decimal>,
478 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
480 pub pe: Option<Decimal>,
481 pub history: Vec<IndustryValuationHistory>,
483}
484
485#[derive(Debug, Clone, Serialize, Deserialize)]
487pub struct IndustryValuationHistory {
488 pub date: String,
490 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
492 pub pe: Option<Decimal>,
493 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
495 pub pb: Option<Decimal>,
496 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
498 pub ps: Option<Decimal>,
499}
500
501#[derive(Debug, Clone, Serialize, Deserialize)]
505pub struct IndustryValuationDist {
506 pub pe: Option<ValuationDist>,
508 pub pb: Option<ValuationDist>,
510 pub ps: Option<ValuationDist>,
512}
513
514#[derive(Debug, Clone, Serialize, Deserialize)]
516pub struct ValuationDist {
517 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
519 pub low: Option<Decimal>,
520 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
522 pub high: Option<Decimal>,
523 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
525 pub median: Option<Decimal>,
526 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
528 pub value: Option<Decimal>,
529 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
531 pub ranking: Option<Decimal>,
532 pub rank_index: String,
534 pub rank_total: String,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize)]
542pub struct CompanyOverview {
543 pub name: String,
545 pub company_name: String,
547 pub founded: String,
549 pub listing_date: String,
551 pub market: String,
553 pub region: String,
555 pub address: String,
557 pub office_address: String,
559 pub website: String,
561 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
563 pub issue_price: Option<Decimal>,
564 pub shares_offered: String,
566 pub chairman: String,
568 pub secretary: String,
570 pub audit_inst: String,
572 pub category: String,
574 pub year_end: String,
576 pub employees: String,
578 #[serde(rename = "Phone")]
580 pub phone: String,
581 pub fax: String,
583 pub email: String,
585 pub legal_repr: String,
587 pub manager: String,
589 pub bus_license: String,
591 pub accounting_firm: String,
593 pub securities_rep: String,
595 pub legal_counsel: String,
597 pub zip_code: String,
599 pub ticker: String,
601 pub icon: String,
603 pub profile: String,
605 #[serde(default)]
607 pub ads_ratio: String,
608 pub sector: i32,
610}
611
612#[derive(Debug, Clone, Serialize, Deserialize)]
616pub struct ExecutiveList {
617 pub professional_list: Vec<ExecutiveGroup>,
619}
620
621#[derive(Debug, Clone, Serialize, Deserialize)]
623pub struct ExecutiveGroup {
624 #[serde(
626 rename = "counter_id",
627 deserialize_with = "deserialize_counter_id_as_symbol"
628 )]
629 pub symbol: String,
630 pub forward_url: String,
632 pub total: i32,
634 pub professionals: Vec<Professional>,
636}
637
638#[derive(Debug, Clone, Serialize, Deserialize)]
640pub struct Professional {
641 pub id: String,
643 pub name: String,
645 pub name_zhcn: String,
647 pub name_en: String,
649 pub title: String,
651 pub biography: String,
653 pub photo: String,
655 pub wiki_url: String,
657}
658
659#[derive(Debug, Clone, Serialize, Deserialize)]
663pub struct ShareholderList {
664 pub shareholder_list: Vec<Shareholder>,
666 #[serde(default)]
668 pub forward_url: String,
669 pub total: i32,
671}
672
673#[derive(Debug, Clone, Serialize, Deserialize)]
675pub struct Shareholder {
676 pub shareholder_id: String,
678 pub shareholder_name: String,
680 pub institution_type: String,
682 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
684 pub percent_of_shares: Option<Decimal>,
685 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
687 pub shares_changed: Option<Decimal>,
688 pub report_date: String,
690 #[serde(default)]
692 pub stocks: Vec<ShareholderStock>,
693}
694
695#[derive(Debug, Clone, Serialize, Deserialize)]
697pub struct ShareholderStock {
698 #[serde(
700 rename = "counter_id",
701 deserialize_with = "deserialize_counter_id_as_symbol"
702 )]
703 pub symbol: String,
704 pub code: String,
706 pub market: String,
708 pub chg: String,
710}
711
712#[derive(Debug, Clone, Serialize, Deserialize)]
716pub struct FundHolders {
717 pub lists: Vec<FundHolder>,
719}
720
721#[derive(Debug, Clone, Serialize, Deserialize)]
723pub struct FundHolder {
724 pub code: String,
726 #[serde(
728 rename = "counter_id",
729 deserialize_with = "deserialize_counter_id_as_symbol"
730 )]
731 pub symbol: String,
732 pub currency: String,
734 pub name: String,
736 #[serde(with = "crate::serde_utils::decimal_empty_is_0")]
738 pub position_ratio: Decimal,
739 pub report_date: String,
741}
742
743#[derive(Debug, Clone, Serialize, Deserialize)]
747pub struct CorpActions {
748 pub items: Vec<CorpActionItem>,
750}
751
752#[derive(Debug, Clone, Serialize, Deserialize)]
754pub struct CorpActionItem {
755 pub id: String,
757 pub date: String,
759 pub date_str: String,
761 pub date_type: String,
763 pub date_zone: String,
765 pub act_type: String,
767 pub act_desc: String,
769 pub action: String,
771 pub recent: bool,
773 pub is_delay: bool,
775 pub delay_content: String,
777 pub live: Option<CorpActionLive>,
779 pub security: Option<serde_json::Value>,
781}
782
783#[derive(Debug, Clone, Serialize, Deserialize)]
785pub struct CorpActionLive {
786 pub id: String,
788 pub status: serde_json::Value, pub started_at: String,
792 pub name: String,
794 pub icon: String,
796}
797
798#[derive(Debug, Clone, Serialize, Deserialize)]
802pub struct InvestRelations {
803 #[serde(default)]
805 pub forward_url: String,
806 pub invest_securities: Vec<InvestSecurity>,
808}
809
810#[derive(Debug, Clone, Serialize, Deserialize)]
812pub struct InvestSecurity {
813 pub company_id: String,
815 pub company_name: String,
817 pub company_name_en: String,
819 pub company_name_zhcn: String,
821 #[serde(
823 rename = "counter_id",
824 deserialize_with = "deserialize_counter_id_as_symbol"
825 )]
826 pub symbol: String,
827 pub currency: String,
829 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
831 pub percent_of_shares: Option<Decimal>,
832 pub shares_rank: String,
834 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
836 pub shares_value: Option<Decimal>,
837}
838
839#[derive(Debug, Clone, Serialize, Deserialize)]
843pub struct OperatingList {
844 pub list: Vec<OperatingItem>,
846}
847
848#[derive(Debug, Clone, Serialize, Deserialize)]
850pub struct OperatingItem {
851 pub id: String,
853 pub report: String,
855 pub title: String,
857 pub txt: String,
859 pub latest: bool,
861 #[serde(default)]
863 pub keywords: Vec<serde_json::Value>,
864 #[serde(default)]
866 pub web_url: String,
867 pub financial: OperatingFinancial,
869}
870
871#[derive(Debug, Clone, Serialize, Deserialize)]
873pub struct OperatingFinancial {
874 pub code: String,
876 pub counter_id: String,
878 pub currency: String,
880 pub name: String,
882 pub region: String,
884 pub report: String,
886 pub report_txt: String,
888 pub indicators: Vec<OperatingIndicator>,
890}
891
892#[derive(Debug, Clone, Serialize, Deserialize)]
894pub struct OperatingIndicator {
895 pub field_name: String,
897 pub indicator_name: String,
899 pub indicator_value: String,
901 #[serde(default, with = "crate::serde_utils::decimal_opt_str_is_none")]
903 pub yoy: Option<Decimal>,
904}
905
906#[derive(Debug, Clone, Serialize, Deserialize)]
910pub struct BuybackData {
911 #[serde(default)]
913 pub recent_buybacks: Option<RecentBuybacks>,
914 #[serde(default)]
916 pub buyback_history: Vec<BuybackHistoryItem>,
917 #[serde(default)]
919 pub buyback_ratios: Vec<BuybackRatios>,
920}
921
922#[derive(Debug, Clone, Serialize, Deserialize)]
924pub struct RecentBuybacks {
925 pub currency: String,
927 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
929 pub net_buyback_ttm: Option<Decimal>,
930 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
932 pub net_buyback_yield_ttm: Option<Decimal>,
933}
934
935#[derive(Debug, Clone, Serialize, Deserialize)]
937pub struct BuybackHistoryItem {
938 pub fiscal_year: String,
940 pub fiscal_year_range: String,
942 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
944 pub net_buyback: Option<Decimal>,
945 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
947 pub net_buyback_yield: Option<Decimal>,
948 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
950 pub net_buyback_growth_rate: Option<Decimal>,
951 pub currency: String,
953}
954
955#[derive(Debug, Clone, Serialize, Deserialize)]
957pub struct BuybackRatios {
958 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
960 pub net_buyback_payout_ratio: Option<Decimal>,
961 #[serde(with = "crate::serde_utils::decimal_opt_str_is_none")]
963 pub net_buyback_to_cashflow_ratio: Option<Decimal>,
964}
965
966#[derive(Debug, Clone, Serialize, Deserialize)]
970pub struct StockRatings {
971 #[serde(default)]
973 pub style_txt_name: String,
974 #[serde(default)]
976 pub scale_txt_name: String,
977 #[serde(default)]
979 pub report_period_txt: String,
980 #[serde(default)]
982 pub multi_score: serde_json::Value,
983 #[serde(default)]
985 pub multi_letter: String,
986 #[serde(default)]
988 pub multi_score_change: i32,
989 #[serde(default)]
991 pub industry_name: String,
992 #[serde(default)]
994 pub industry_rank: serde_json::Value,
995 #[serde(default)]
997 pub industry_total: serde_json::Value,
998 #[serde(default)]
1000 pub industry_mean_score: serde_json::Value,
1001 #[serde(default)]
1003 pub industry_median_score: serde_json::Value,
1004 #[serde(default)]
1006 pub ratings: Vec<RatingCategory>,
1007}
1008
1009#[derive(Debug, Clone, Serialize, Deserialize)]
1011pub struct RatingCategory {
1012 #[serde(rename = "type")]
1014 pub kind: i32,
1015 #[serde(default)]
1017 pub sub_indicators: Vec<RatingSubIndicatorGroup>,
1018}
1019
1020#[derive(Debug, Clone, Serialize, Deserialize)]
1022pub struct RatingSubIndicatorGroup {
1023 pub indicator: RatingIndicator,
1025 #[serde(default)]
1027 pub sub_indicators: Vec<RatingLeafIndicator>,
1028}
1029
1030#[derive(Debug, Clone, Serialize, Deserialize)]
1032pub struct RatingIndicator {
1033 pub name: String,
1035 #[serde(default)]
1037 pub score: serde_json::Value,
1038 #[serde(default)]
1040 pub letter: String,
1041}
1042
1043#[derive(Debug, Clone, Serialize, Deserialize)]
1045pub struct RatingLeafIndicator {
1046 pub name: String,
1048 #[serde(default)]
1050 pub value: String,
1051 #[serde(default)]
1053 pub value_type: String,
1054 #[serde(default)]
1056 pub score: serde_json::Value,
1057 #[serde(default)]
1059 pub letter: String,
1060}
1061
1062#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq, EnumString, Display)]
1066pub enum InstitutionRecommend {
1067 Unknown,
1069 #[strum(serialize = "strong_buy")]
1071 StrongBuy,
1072 #[strum(serialize = "buy")]
1074 Buy,
1075 #[strum(serialize = "hold")]
1077 Hold,
1078 #[strum(serialize = "sell")]
1080 Sell,
1081 #[strum(serialize = "strong_sell")]
1083 StrongSell,
1084 #[strum(serialize = "underperform")]
1086 Underperform,
1087 #[strum(serialize = "no_opinion")]
1089 NoOpinion,
1090}
1091
1092impl_default_for_enum_string!(InstitutionRecommend);
1093impl_serde_for_enum_string!(InstitutionRecommend);
1094
1095#[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, Default)]
1097pub enum FinancialReportKind {
1098 #[serde(rename = "IS")]
1100 IncomeStatement,
1101 #[serde(rename = "BS")]
1103 BalanceSheet,
1104 #[serde(rename = "CF")]
1106 CashFlow,
1107 #[default]
1109 #[serde(rename = "ALL")]
1110 All,
1111}
1112
1113#[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
1115pub enum FinancialReportPeriod {
1116 #[serde(rename = "af")]
1118 Annual,
1119 #[serde(rename = "saf")]
1121 SemiAnnual,
1122 #[serde(rename = "q1")]
1124 Q1,
1125 #[serde(rename = "q2")]
1127 Q2,
1128 #[serde(rename = "q3")]
1130 Q3,
1131 #[serde(rename = "qf")]
1133 QuarterlyFull,
1134 #[serde(rename = "3q")]
1136 ThreeQ,
1137}