use chrono::{DateTime, NaiveDate, Utc};
use serde::{Deserialize, Serialize};
use crate::Decimal;
pub const API_VERSION: &str = "1.0.0-beta.2";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum MetricPeriod {
#[serde(rename = "latest")]
Latest,
#[serde(rename = "annual")]
Annual,
#[serde(rename = "quarterly")]
Quarterly,
#[serde(rename = "all")]
All,
#[serde(other, rename = "unknown")]
Unknown,
}
impl MetricPeriod {
pub const VALUES: [MetricPeriod; 4] = [
MetricPeriod::Latest,
MetricPeriod::Annual,
MetricPeriod::Quarterly,
MetricPeriod::All,
];
pub fn as_str(self) -> &'static str {
match self {
MetricPeriod::Latest => "latest",
MetricPeriod::Annual => "annual",
MetricPeriod::Quarterly => "quarterly",
MetricPeriod::All => "all",
MetricPeriod::Unknown => "unknown",
}
}
}
impl std::fmt::Display for MetricPeriod {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ValueKind {
#[serde(rename = "reported")]
Reported,
#[serde(rename = "derived")]
Derived,
#[serde(other, rename = "unknown")]
Unknown,
}
impl ValueKind {
pub const VALUES: [ValueKind; 2] = [ValueKind::Reported, ValueKind::Derived];
pub fn as_str(self) -> &'static str {
match self {
ValueKind::Reported => "reported",
ValueKind::Derived => "derived",
ValueKind::Unknown => "unknown",
}
}
}
impl std::fmt::Display for ValueKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum RevisionKind {
#[serde(rename = "first")]
First,
#[serde(rename = "same")]
Same,
#[serde(rename = "revised")]
Revised,
#[serde(rename = "re_expressed")]
ReExpressed,
#[serde(other, rename = "unknown")]
Unknown,
}
impl RevisionKind {
pub const VALUES: [RevisionKind; 4] = [
RevisionKind::First,
RevisionKind::Same,
RevisionKind::Revised,
RevisionKind::ReExpressed,
];
pub fn as_str(self) -> &'static str {
match self {
RevisionKind::First => "first",
RevisionKind::Same => "same",
RevisionKind::Revised => "revised",
RevisionKind::ReExpressed => "re_expressed",
RevisionKind::Unknown => "unknown",
}
}
}
impl std::fmt::Display for RevisionKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum MatchQuality {
#[serde(rename = "unique")]
Unique,
#[serde(rename = "ambiguous")]
Ambiguous,
#[serde(rename = "hidden_only")]
HiddenOnly,
#[serde(rename = "none")]
None,
#[serde(other, rename = "unknown")]
Unknown,
}
impl MatchQuality {
pub const VALUES: [MatchQuality; 4] = [
MatchQuality::Unique,
MatchQuality::Ambiguous,
MatchQuality::HiddenOnly,
MatchQuality::None,
];
pub fn as_str(self) -> &'static str {
match self {
MatchQuality::Unique => "unique",
MatchQuality::Ambiguous => "ambiguous",
MatchQuality::HiddenOnly => "hidden_only",
MatchQuality::None => "none",
MatchQuality::Unknown => "unknown",
}
}
}
impl std::fmt::Display for MatchQuality {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AnnouncementTiming {
#[serde(rename = "before_open")]
BeforeOpen,
#[serde(rename = "during_market")]
DuringMarket,
#[serde(rename = "after_close")]
AfterClose,
#[serde(other, rename = "unknown")]
Unknown,
}
impl AnnouncementTiming {
pub const VALUES: [AnnouncementTiming; 3] = [
AnnouncementTiming::BeforeOpen,
AnnouncementTiming::DuringMarket,
AnnouncementTiming::AfterClose,
];
pub fn as_str(self) -> &'static str {
match self {
AnnouncementTiming::BeforeOpen => "before_open",
AnnouncementTiming::DuringMarket => "during_market",
AnnouncementTiming::AfterClose => "after_close",
AnnouncementTiming::Unknown => "unknown",
}
}
}
impl std::fmt::Display for AnnouncementTiming {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum TradeKind {
#[serde(rename = "purchase")]
Purchase,
#[serde(rename = "sale")]
Sale,
#[serde(other, rename = "unknown")]
Unknown,
}
impl TradeKind {
pub const VALUES: [TradeKind; 2] = [TradeKind::Purchase, TradeKind::Sale];
pub fn as_str(self) -> &'static str {
match self {
TradeKind::Purchase => "purchase",
TradeKind::Sale => "sale",
TradeKind::Unknown => "unknown",
}
}
}
impl std::fmt::Display for TradeKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum InsiderKind {
#[serde(rename = "all")]
All,
#[serde(rename = "purchase")]
Purchase,
#[serde(rename = "sale")]
Sale,
#[serde(other, rename = "unknown")]
Unknown,
}
impl InsiderKind {
pub const VALUES: [InsiderKind; 3] =
[InsiderKind::All, InsiderKind::Purchase, InsiderKind::Sale];
pub fn as_str(self) -> &'static str {
match self {
InsiderKind::All => "all",
InsiderKind::Purchase => "purchase",
InsiderKind::Sale => "sale",
InsiderKind::Unknown => "unknown",
}
}
}
impl std::fmt::Display for InsiderKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum InsiderForm {
#[serde(rename = "4")]
Form4,
#[serde(rename = "4/A")]
Form4A,
#[serde(rename = "5")]
Form5,
#[serde(rename = "5/A")]
Form5A,
#[serde(other, rename = "unknown")]
Unknown,
}
impl InsiderForm {
pub const VALUES: [InsiderForm; 4] = [
InsiderForm::Form4,
InsiderForm::Form4A,
InsiderForm::Form5,
InsiderForm::Form5A,
];
pub fn as_str(self) -> &'static str {
match self {
InsiderForm::Form4 => "4",
InsiderForm::Form4A => "4/A",
InsiderForm::Form5 => "5",
InsiderForm::Form5A => "5/A",
InsiderForm::Unknown => "unknown",
}
}
}
impl std::fmt::Display for InsiderForm {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum TransactionCode {
#[serde(rename = "P")]
Purchase,
#[serde(rename = "S")]
Sale,
#[serde(other, rename = "unknown")]
Unknown,
}
impl TransactionCode {
pub const VALUES: [TransactionCode; 2] = [TransactionCode::Purchase, TransactionCode::Sale];
pub fn as_str(self) -> &'static str {
match self {
TransactionCode::Purchase => "P",
TransactionCode::Sale => "S",
TransactionCode::Unknown => "unknown",
}
}
}
impl std::fmt::Display for TransactionCode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ValueStatus {
#[serde(rename = "counted")]
Counted,
#[serde(rename = "suspect")]
Suspect,
#[serde(rename = "not_equity")]
NotEquity,
#[serde(other, rename = "unknown")]
Unknown,
}
impl ValueStatus {
pub const VALUES: [ValueStatus; 3] = [
ValueStatus::Counted,
ValueStatus::Suspect,
ValueStatus::NotEquity,
];
pub fn as_str(self) -> &'static str {
match self {
ValueStatus::Counted => "counted",
ValueStatus::Suspect => "suspect",
ValueStatus::NotEquity => "not_equity",
ValueStatus::Unknown => "unknown",
}
}
}
impl std::fmt::Display for ValueStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PriceActionKind {
#[serde(rename = "split")]
Split,
#[serde(rename = "dividend")]
Dividend,
#[serde(rename = "ticker_change")]
TickerChange,
#[serde(other, rename = "unknown")]
Unknown,
}
impl PriceActionKind {
pub const VALUES: [PriceActionKind; 3] = [
PriceActionKind::Split,
PriceActionKind::Dividend,
PriceActionKind::TickerChange,
];
pub fn as_str(self) -> &'static str {
match self {
PriceActionKind::Split => "split",
PriceActionKind::Dividend => "dividend",
PriceActionKind::TickerChange => "ticker_change",
PriceActionKind::Unknown => "unknown",
}
}
}
impl std::fmt::Display for PriceActionKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PriceSource {
#[serde(rename = "iex")]
Iex,
#[serde(rename = "fails")]
Fails,
#[serde(rename = "iex_official")]
IexOfficial,
#[serde(rename = "thirteen_f")]
ThirteenF,
#[serde(rename = "nport")]
Nport,
#[serde(other, rename = "unknown")]
Unknown,
}
impl PriceSource {
pub const VALUES: [PriceSource; 5] = [
PriceSource::Iex,
PriceSource::Fails,
PriceSource::IexOfficial,
PriceSource::ThirteenF,
PriceSource::Nport,
];
pub fn as_str(self) -> &'static str {
match self {
PriceSource::Iex => "iex",
PriceSource::Fails => "fails",
PriceSource::IexOfficial => "iex_official",
PriceSource::ThirteenF => "thirteen_f",
PriceSource::Nport => "nport",
PriceSource::Unknown => "unknown",
}
}
}
impl std::fmt::Display for PriceSource {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PriceRange {
#[serde(rename = "1m")]
OneMonth,
#[serde(rename = "3m")]
ThreeMonths,
#[serde(rename = "1y")]
OneYear,
#[serde(rename = "5y")]
FiveYears,
#[serde(rename = "max")]
Max,
#[serde(other, rename = "unknown")]
Unknown,
}
impl PriceRange {
pub const VALUES: [PriceRange; 5] = [
PriceRange::OneMonth,
PriceRange::ThreeMonths,
PriceRange::OneYear,
PriceRange::FiveYears,
PriceRange::Max,
];
pub fn as_str(self) -> &'static str {
match self {
PriceRange::OneMonth => "1m",
PriceRange::ThreeMonths => "3m",
PriceRange::OneYear => "1y",
PriceRange::FiveYears => "5y",
PriceRange::Max => "max",
PriceRange::Unknown => "unknown",
}
}
}
impl std::fmt::Display for PriceRange {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum Axis {
#[serde(rename = "segment")]
Segment,
#[serde(rename = "geography")]
Geography,
#[serde(rename = "product")]
Product,
#[serde(other, rename = "unknown")]
Unknown,
}
impl Axis {
pub const VALUES: [Axis; 3] = [Axis::Segment, Axis::Geography, Axis::Product];
pub fn as_str(self) -> &'static str {
match self {
Axis::Segment => "segment",
Axis::Geography => "geography",
Axis::Product => "product",
Axis::Unknown => "unknown",
}
}
}
impl std::fmt::Display for Axis {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum Measure {
#[serde(rename = "revenue")]
Revenue,
#[serde(rename = "operating_income")]
OperatingIncome,
#[serde(rename = "gross_profit")]
GrossProfit,
#[serde(rename = "cost_of_revenue")]
CostOfRevenue,
#[serde(rename = "assets")]
Assets,
#[serde(rename = "long_lived_assets")]
LongLivedAssets,
#[serde(rename = "capital_expenditure")]
CapitalExpenditure,
#[serde(rename = "depreciation")]
Depreciation,
#[serde(other, rename = "unknown")]
Unknown,
}
impl Measure {
pub const VALUES: [Measure; 8] = [
Measure::Revenue,
Measure::OperatingIncome,
Measure::GrossProfit,
Measure::CostOfRevenue,
Measure::Assets,
Measure::LongLivedAssets,
Measure::CapitalExpenditure,
Measure::Depreciation,
];
pub fn as_str(self) -> &'static str {
match self {
Measure::Revenue => "revenue",
Measure::OperatingIncome => "operating_income",
Measure::GrossProfit => "gross_profit",
Measure::CostOfRevenue => "cost_of_revenue",
Measure::Assets => "assets",
Measure::LongLivedAssets => "long_lived_assets",
Measure::CapitalExpenditure => "capital_expenditure",
Measure::Depreciation => "depreciation",
Measure::Unknown => "unknown",
}
}
}
impl std::fmt::Display for Measure {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SegmentsPeriod {
#[serde(rename = "annual")]
Annual,
#[serde(rename = "quarterly")]
Quarterly,
#[serde(other, rename = "unknown")]
Unknown,
}
impl SegmentsPeriod {
pub const VALUES: [SegmentsPeriod; 2] = [SegmentsPeriod::Annual, SegmentsPeriod::Quarterly];
pub fn as_str(self) -> &'static str {
match self {
SegmentsPeriod::Annual => "annual",
SegmentsPeriod::Quarterly => "quarterly",
SegmentsPeriod::Unknown => "unknown",
}
}
}
impl std::fmt::Display for SegmentsPeriod {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SortDirection {
#[serde(rename = "asc")]
Asc,
#[serde(rename = "desc")]
Desc,
#[serde(other, rename = "unknown")]
Unknown,
}
impl SortDirection {
pub const VALUES: [SortDirection; 2] = [SortDirection::Asc, SortDirection::Desc];
pub fn as_str(self) -> &'static str {
match self {
SortDirection::Asc => "asc",
SortDirection::Desc => "desc",
SortDirection::Unknown => "unknown",
}
}
}
impl std::fmt::Display for SortDirection {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ReleaseChecks {
#[serde(rename = "passed")]
Passed,
#[serde(rename = "failed")]
Failed,
#[serde(other, rename = "unknown")]
Unknown,
}
impl ReleaseChecks {
pub const VALUES: [ReleaseChecks; 2] = [ReleaseChecks::Passed, ReleaseChecks::Failed];
pub fn as_str(self) -> &'static str {
match self {
ReleaseChecks::Passed => "passed",
ReleaseChecks::Failed => "failed",
ReleaseChecks::Unknown => "unknown",
}
}
}
impl std::fmt::Display for ReleaseChecks {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ProblemCode {
#[serde(rename = "bad_request")]
BadRequest,
#[serde(rename = "missing_key")]
MissingKey,
#[serde(rename = "invalid_key")]
InvalidKey,
#[serde(rename = "revoked_key")]
RevokedKey,
#[serde(rename = "expired_key")]
ExpiredKey,
#[serde(rename = "not_found")]
NotFound,
#[serde(rename = "method_not_allowed")]
MethodNotAllowed,
#[serde(rename = "rate_limited")]
RateLimited,
#[serde(rename = "internal_error")]
InternalError,
#[serde(rename = "unavailable")]
Unavailable,
#[serde(rename = "timeout")]
Timeout,
#[serde(other, rename = "unknown")]
Unknown,
}
impl ProblemCode {
pub const VALUES: [ProblemCode; 11] = [
ProblemCode::BadRequest,
ProblemCode::MissingKey,
ProblemCode::InvalidKey,
ProblemCode::RevokedKey,
ProblemCode::ExpiredKey,
ProblemCode::NotFound,
ProblemCode::MethodNotAllowed,
ProblemCode::RateLimited,
ProblemCode::InternalError,
ProblemCode::Unavailable,
ProblemCode::Timeout,
];
pub fn as_str(self) -> &'static str {
match self {
ProblemCode::BadRequest => "bad_request",
ProblemCode::MissingKey => "missing_key",
ProblemCode::InvalidKey => "invalid_key",
ProblemCode::RevokedKey => "revoked_key",
ProblemCode::ExpiredKey => "expired_key",
ProblemCode::NotFound => "not_found",
ProblemCode::MethodNotAllowed => "method_not_allowed",
ProblemCode::RateLimited => "rate_limited",
ProblemCode::InternalError => "internal_error",
ProblemCode::Unavailable => "unavailable",
ProblemCode::Timeout => "timeout",
ProblemCode::Unknown => "unknown",
}
}
}
impl std::fmt::Display for ProblemCode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum LimitPolicy {
#[serde(rename = "minute")]
Minute,
#[serde(rename = "month")]
Month,
#[serde(rename = "concurrent")]
Concurrent,
#[serde(other, rename = "unknown")]
Unknown,
}
impl LimitPolicy {
pub const VALUES: [LimitPolicy; 3] = [
LimitPolicy::Minute,
LimitPolicy::Month,
LimitPolicy::Concurrent,
];
pub fn as_str(self) -> &'static str {
match self {
LimitPolicy::Minute => "minute",
LimitPolicy::Month => "month",
LimitPolicy::Concurrent => "concurrent",
LimitPolicy::Unknown => "unknown",
}
}
}
impl std::fmt::Display for LimitPolicy {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ScreenColumn {
#[serde(rename = "coverage_state")]
CoverageState,
#[serde(rename = "fiscal_year")]
FiscalYear,
#[serde(rename = "annual_end_date")]
AnnualEndDate,
#[serde(rename = "instant_end_date")]
InstantEndDate,
#[serde(rename = "prior_annual_end_date")]
PriorAnnualEndDate,
#[serde(rename = "public_float_end_date")]
PublicFloatEndDate,
#[serde(rename = "shares_outstanding_end_date")]
SharesOutstandingEndDate,
#[serde(rename = "revenue")]
Revenue,
#[serde(rename = "gross_profit")]
GrossProfit,
#[serde(rename = "operating_income")]
OperatingIncome,
#[serde(rename = "net_income")]
NetIncome,
#[serde(rename = "eps_diluted")]
EpsDiluted,
#[serde(rename = "operating_cash_flow")]
OperatingCashFlow,
#[serde(rename = "capital_expenditures")]
CapitalExpenditures,
#[serde(rename = "free_cash_flow")]
FreeCashFlow,
#[serde(rename = "share_based_compensation")]
ShareBasedCompensation,
#[serde(rename = "depreciation_and_amortization")]
DepreciationAndAmortization,
#[serde(rename = "revenue_prior")]
RevenuePrior,
#[serde(rename = "net_income_prior")]
NetIncomePrior,
#[serde(rename = "assets")]
Assets,
#[serde(rename = "current_assets")]
CurrentAssets,
#[serde(rename = "cash_and_equivalents")]
CashAndEquivalents,
#[serde(rename = "liabilities")]
Liabilities,
#[serde(rename = "current_liabilities")]
CurrentLiabilities,
#[serde(rename = "stockholders_equity")]
StockholdersEquity,
#[serde(rename = "common_shares_outstanding")]
CommonSharesOutstanding,
#[serde(rename = "public_float")]
PublicFloat,
#[serde(rename = "gross_margin")]
GrossMargin,
#[serde(rename = "operating_margin")]
OperatingMargin,
#[serde(rename = "net_margin")]
NetMargin,
#[serde(rename = "fcf_margin")]
FcfMargin,
#[serde(rename = "roe")]
Roe,
#[serde(rename = "roa")]
Roa,
#[serde(rename = "current_ratio")]
CurrentRatio,
#[serde(rename = "cash_ratio")]
CashRatio,
#[serde(rename = "liabilities_to_equity")]
LiabilitiesToEquity,
#[serde(rename = "revenue_yoy")]
RevenueYoy,
#[serde(rename = "net_income_yoy")]
NetIncomeYoy,
#[serde(rename = "capex_intensity")]
CapexIntensity,
#[serde(rename = "sbc_intensity")]
SbcIntensity,
#[serde(rename = "dividends_paid")]
DividendsPaid,
#[serde(rename = "share_repurchases")]
ShareRepurchases,
#[serde(rename = "dividends_per_share")]
DividendsPerShare,
#[serde(rename = "capital_returns")]
CapitalReturns,
#[serde(rename = "payout_ratio")]
PayoutRatio,
#[serde(rename = "capital_returns_to_fcf")]
CapitalReturnsToFcf,
#[serde(rename = "shares_change")]
SharesChange,
#[serde(rename = "price")]
Price,
#[serde(rename = "price_day")]
PriceDay,
#[serde(rename = "market_cap")]
MarketCap,
#[serde(rename = "pe")]
Pe,
#[serde(rename = "ps")]
Ps,
#[serde(rename = "pb")]
Pb,
#[serde(rename = "fcf_yield")]
FcfYield,
#[serde(rename = "dividend_yield")]
DividendYield,
#[serde(rename = "ttm_end_date")]
TtmEndDate,
#[serde(rename = "revenue_ttm")]
RevenueTtm,
#[serde(rename = "net_income_ttm")]
NetIncomeTtm,
#[serde(rename = "operating_cash_flow_ttm")]
OperatingCashFlowTtm,
#[serde(rename = "free_cash_flow_ttm")]
FreeCashFlowTtm,
#[serde(rename = "pe_ttm")]
PeTtm,
#[serde(rename = "ps_ttm")]
PsTtm,
#[serde(rename = "fcf_yield_ttm")]
FcfYieldTtm,
#[serde(other, rename = "unknown")]
Unknown,
}
impl ScreenColumn {
pub const VALUES: [ScreenColumn; 63] = [
ScreenColumn::CoverageState,
ScreenColumn::FiscalYear,
ScreenColumn::AnnualEndDate,
ScreenColumn::InstantEndDate,
ScreenColumn::PriorAnnualEndDate,
ScreenColumn::PublicFloatEndDate,
ScreenColumn::SharesOutstandingEndDate,
ScreenColumn::Revenue,
ScreenColumn::GrossProfit,
ScreenColumn::OperatingIncome,
ScreenColumn::NetIncome,
ScreenColumn::EpsDiluted,
ScreenColumn::OperatingCashFlow,
ScreenColumn::CapitalExpenditures,
ScreenColumn::FreeCashFlow,
ScreenColumn::ShareBasedCompensation,
ScreenColumn::DepreciationAndAmortization,
ScreenColumn::RevenuePrior,
ScreenColumn::NetIncomePrior,
ScreenColumn::Assets,
ScreenColumn::CurrentAssets,
ScreenColumn::CashAndEquivalents,
ScreenColumn::Liabilities,
ScreenColumn::CurrentLiabilities,
ScreenColumn::StockholdersEquity,
ScreenColumn::CommonSharesOutstanding,
ScreenColumn::PublicFloat,
ScreenColumn::GrossMargin,
ScreenColumn::OperatingMargin,
ScreenColumn::NetMargin,
ScreenColumn::FcfMargin,
ScreenColumn::Roe,
ScreenColumn::Roa,
ScreenColumn::CurrentRatio,
ScreenColumn::CashRatio,
ScreenColumn::LiabilitiesToEquity,
ScreenColumn::RevenueYoy,
ScreenColumn::NetIncomeYoy,
ScreenColumn::CapexIntensity,
ScreenColumn::SbcIntensity,
ScreenColumn::DividendsPaid,
ScreenColumn::ShareRepurchases,
ScreenColumn::DividendsPerShare,
ScreenColumn::CapitalReturns,
ScreenColumn::PayoutRatio,
ScreenColumn::CapitalReturnsToFcf,
ScreenColumn::SharesChange,
ScreenColumn::Price,
ScreenColumn::PriceDay,
ScreenColumn::MarketCap,
ScreenColumn::Pe,
ScreenColumn::Ps,
ScreenColumn::Pb,
ScreenColumn::FcfYield,
ScreenColumn::DividendYield,
ScreenColumn::TtmEndDate,
ScreenColumn::RevenueTtm,
ScreenColumn::NetIncomeTtm,
ScreenColumn::OperatingCashFlowTtm,
ScreenColumn::FreeCashFlowTtm,
ScreenColumn::PeTtm,
ScreenColumn::PsTtm,
ScreenColumn::FcfYieldTtm,
];
pub fn as_str(self) -> &'static str {
match self {
ScreenColumn::CoverageState => "coverage_state",
ScreenColumn::FiscalYear => "fiscal_year",
ScreenColumn::AnnualEndDate => "annual_end_date",
ScreenColumn::InstantEndDate => "instant_end_date",
ScreenColumn::PriorAnnualEndDate => "prior_annual_end_date",
ScreenColumn::PublicFloatEndDate => "public_float_end_date",
ScreenColumn::SharesOutstandingEndDate => "shares_outstanding_end_date",
ScreenColumn::Revenue => "revenue",
ScreenColumn::GrossProfit => "gross_profit",
ScreenColumn::OperatingIncome => "operating_income",
ScreenColumn::NetIncome => "net_income",
ScreenColumn::EpsDiluted => "eps_diluted",
ScreenColumn::OperatingCashFlow => "operating_cash_flow",
ScreenColumn::CapitalExpenditures => "capital_expenditures",
ScreenColumn::FreeCashFlow => "free_cash_flow",
ScreenColumn::ShareBasedCompensation => "share_based_compensation",
ScreenColumn::DepreciationAndAmortization => "depreciation_and_amortization",
ScreenColumn::RevenuePrior => "revenue_prior",
ScreenColumn::NetIncomePrior => "net_income_prior",
ScreenColumn::Assets => "assets",
ScreenColumn::CurrentAssets => "current_assets",
ScreenColumn::CashAndEquivalents => "cash_and_equivalents",
ScreenColumn::Liabilities => "liabilities",
ScreenColumn::CurrentLiabilities => "current_liabilities",
ScreenColumn::StockholdersEquity => "stockholders_equity",
ScreenColumn::CommonSharesOutstanding => "common_shares_outstanding",
ScreenColumn::PublicFloat => "public_float",
ScreenColumn::GrossMargin => "gross_margin",
ScreenColumn::OperatingMargin => "operating_margin",
ScreenColumn::NetMargin => "net_margin",
ScreenColumn::FcfMargin => "fcf_margin",
ScreenColumn::Roe => "roe",
ScreenColumn::Roa => "roa",
ScreenColumn::CurrentRatio => "current_ratio",
ScreenColumn::CashRatio => "cash_ratio",
ScreenColumn::LiabilitiesToEquity => "liabilities_to_equity",
ScreenColumn::RevenueYoy => "revenue_yoy",
ScreenColumn::NetIncomeYoy => "net_income_yoy",
ScreenColumn::CapexIntensity => "capex_intensity",
ScreenColumn::SbcIntensity => "sbc_intensity",
ScreenColumn::DividendsPaid => "dividends_paid",
ScreenColumn::ShareRepurchases => "share_repurchases",
ScreenColumn::DividendsPerShare => "dividends_per_share",
ScreenColumn::CapitalReturns => "capital_returns",
ScreenColumn::PayoutRatio => "payout_ratio",
ScreenColumn::CapitalReturnsToFcf => "capital_returns_to_fcf",
ScreenColumn::SharesChange => "shares_change",
ScreenColumn::Price => "price",
ScreenColumn::PriceDay => "price_day",
ScreenColumn::MarketCap => "market_cap",
ScreenColumn::Pe => "pe",
ScreenColumn::Ps => "ps",
ScreenColumn::Pb => "pb",
ScreenColumn::FcfYield => "fcf_yield",
ScreenColumn::DividendYield => "dividend_yield",
ScreenColumn::TtmEndDate => "ttm_end_date",
ScreenColumn::RevenueTtm => "revenue_ttm",
ScreenColumn::NetIncomeTtm => "net_income_ttm",
ScreenColumn::OperatingCashFlowTtm => "operating_cash_flow_ttm",
ScreenColumn::FreeCashFlowTtm => "free_cash_flow_ttm",
ScreenColumn::PeTtm => "pe_ttm",
ScreenColumn::PsTtm => "ps_ttm",
ScreenColumn::FcfYieldTtm => "fcf_yield_ttm",
ScreenColumn::Unknown => "unknown",
}
}
}
impl std::fmt::Display for ScreenColumn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Attribution {
pub text: String,
pub url: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FactLocation {
#[serde(default)]
pub concept: Option<String>,
#[serde(default)]
pub context: Option<String>,
#[serde(default)]
pub document: Option<String>,
#[serde(default)]
pub line_id: Option<String>,
pub match_quality: MatchQuality,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Filing {
#[serde(default)]
pub accepted_at: Option<DateTime<Utc>>,
pub accession_number: String,
#[serde(default)]
pub announcement_timing: Option<AnnouncementTiming>,
pub cik: i64,
pub entity_name: String,
#[serde(default)]
pub exchange: Option<String>,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
#[serde(default)]
pub fiscal_period: Option<String>,
#[serde(default)]
pub fiscal_year: Option<i64>,
pub form: String,
#[serde(default)]
pub items: Option<Vec<String>>,
#[serde(default)]
pub primary_document: Option<String>,
#[serde(default)]
pub report_date: Option<NaiveDate>,
#[serde(default)]
pub source_url: Option<String>,
#[serde(default)]
pub ticker: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingSource {
#[serde(default)]
pub accepted_at: Option<DateTime<Utc>>,
pub accession_number: String,
pub cik: i64,
pub documents: Vec<FilingSourceDocument>,
pub entity_name: String,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
pub folder: String,
pub form: String,
#[serde(default)]
pub ticker: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingSourceDocument {
pub document: String,
pub kind: String,
pub read: bool,
pub url: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingSourceEnvelope {
pub data: FilingSource,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDay {
pub companies: i64,
pub date: NaiveDate,
pub days: Vec<FilingsDayCount>,
pub filings: i64,
pub forms: Vec<FilingsDayForm>,
pub insiders: FilingsDayInsiders,
pub latest: NaiveDate,
pub lines: Vec<Filing>,
pub lines_total: i64,
#[serde(default)]
pub live: Option<bool>,
pub reports: Vec<FilingsDayReport>,
#[serde(default)]
pub updated_at: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayCount {
pub date: NaiveDate,
pub filings: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayEnvelope {
pub data: FilingsDay,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayForm {
pub filings: i64,
pub form: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayInsiders {
pub largest: Vec<FilingsDayTrade>,
pub purchase_value: Decimal,
pub purchases: i64,
pub sale_value: Decimal,
pub sales: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayReport {
#[serde(default)]
pub accepted_at: Option<DateTime<Utc>>,
pub accession_number: String,
pub cik: i64,
pub entity_name: String,
#[serde(default)]
pub exchange: Option<String>,
#[serde(default)]
pub fiscal_period: Option<String>,
#[serde(default)]
pub fiscal_year: Option<i64>,
pub form: String,
#[serde(default)]
pub prior_revenue: Option<Decimal>,
#[serde(default)]
pub report_date: Option<NaiveDate>,
#[serde(default)]
pub revenue: Option<Decimal>,
#[serde(default)]
pub revenue_end: Option<NaiveDate>,
#[serde(default)]
pub revenue_start: Option<NaiveDate>,
#[serde(default)]
pub source_url: Option<String>,
#[serde(default)]
pub ticker: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsDayTrade {
pub accession_number: String,
pub cik: i64,
pub entity_name: String,
pub is_director: bool,
pub is_officer: bool,
pub is_ten_percent_owner: bool,
pub kind: TradeKind,
#[serde(default)]
pub officer_title: Option<String>,
#[serde(default)]
pub owner_name: Option<String>,
pub shares: Decimal,
pub source_url: String,
#[serde(default)]
pub ticker: Option<String>,
pub value: Decimal,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct FilingsEnvelope {
pub data: Vec<Filing>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Holder {
pub accession_number: String,
pub cik: i64,
#[serde(default)]
pub closed: Option<i64>,
pub filed_at: NaiveDate,
pub name: String,
#[serde(default)]
pub opened: Option<i64>,
pub other_managers: i64,
pub period: NaiveDate,
pub positions: i64,
#[serde(default)]
pub prior_period: Option<NaiveDate>,
pub quarters: Vec<HolderQuarter>,
pub rows: Vec<HolderPosition>,
pub rows_total: i64,
pub value_total: Decimal,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct HolderEnvelope {
pub data: Holder,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct HolderHit {
pub cik: i64,
#[serde(default)]
pub latest_period: Option<NaiveDate>,
#[serde(default)]
pub latest_positions: Option<i64>,
#[serde(default)]
pub latest_value: Option<Decimal>,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct HolderHitsEnvelope {
pub data: Vec<HolderHit>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct HolderPosition {
pub amount: Decimal,
pub amount_type: String,
#[serde(default)]
pub cik: Option<i64>,
pub class: String,
pub cusip: String,
#[serde(default)]
pub entity_name: Option<String>,
pub issuer: String,
#[serde(default)]
pub prior_amount: Option<Decimal>,
#[serde(default)]
pub prior_value: Option<Decimal>,
pub put_call: String,
#[serde(default)]
pub ticker: Option<String>,
pub value: Decimal,
#[serde(default)]
pub weight: Option<Decimal>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct HolderQuarter {
pub accession_number: String,
pub filed_at: NaiveDate,
pub period: NaiveDate,
pub positions: i64,
pub value_total: Decimal,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderActivityEnvelope {
pub data: InsiderActivityPage,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderActivityPage {
pub filings: Vec<InsiderFiling>,
pub purchase_transactions: i64,
pub reported_purchase_value: Decimal,
pub reported_sale_value: Decimal,
pub sale_transactions: i64,
pub total_transactions: i64,
pub uncounted_transactions: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderFiling {
pub accession_number: String,
#[serde(default)]
pub aff10b5_one: Option<bool>,
pub cik: i64,
pub entity_name: String,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
pub footnotes: Vec<InsiderFootnote>,
pub form: InsiderForm,
pub is_amendment: bool,
pub owners: Vec<InsiderOwner>,
#[serde(default)]
pub period_of_report: Option<NaiveDate>,
pub source_url: String,
#[serde(default)]
pub ticker: Option<String>,
pub transactions: Vec<InsiderTransaction>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderFootnote {
pub id: String,
pub text: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderOwner {
pub cik: i64,
pub is_director: bool,
pub is_officer: bool,
pub is_other: bool,
pub is_ten_percent_owner: bool,
pub name: String,
#[serde(default)]
pub officer_title: Option<String>,
#[serde(default)]
pub other_text: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct InsiderTransaction {
#[serde(default)]
pub acquired_disposed_code: Option<String>,
#[serde(default)]
pub direct_indirect_ownership: Option<String>,
pub footnote_ids: Vec<String>,
#[serde(default)]
pub nature_of_ownership: Option<String>,
pub ordinal: i64,
#[serde(default)]
pub price_per_share: Option<Decimal>,
pub security_title: String,
#[serde(default)]
pub shares: Option<Decimal>,
#[serde(default)]
pub shares_owned_following: Option<Decimal>,
pub transaction_code: TransactionCode,
#[serde(default)]
pub transaction_date: Option<NaiveDate>,
#[serde(default)]
pub transaction_value: Option<Decimal>,
pub value_status: ValueStatus,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricCatalogEntry {
pub covered_company_count: i64,
pub description: String,
#[serde(default)]
pub formula: Option<String>,
pub key: String,
pub label: String,
pub mappings: Vec<MetricMapping>,
#[serde(default)]
pub statement: Option<String>,
#[serde(default)]
pub unit: Option<String>,
pub value_kind: ValueKind,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricCatalogEnvelope {
pub data: Vec<MetricCatalogEntry>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricLineage {
#[serde(default)]
pub accession_number: Option<String>,
pub cik: i64,
pub concept: String,
pub end_date: NaiveDate,
pub entity_name: String,
#[serde(default)]
pub exchange: Option<String>,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
#[serde(default)]
pub fiscal_period: Option<String>,
#[serde(default)]
pub fiscal_year: Option<i64>,
#[serde(default)]
pub form: Option<String>,
#[serde(default)]
pub frame: Option<String>,
#[serde(default)]
pub location: Option<FactLocation>,
pub metric_key: String,
pub metric_label: String,
pub metric_unit: String,
pub metric_value: Decimal,
pub metric_value_id: String,
pub period_kind: String,
pub raw_fact_id: String,
#[serde(default)]
pub raw_ingestion_run_id: Option<String>,
pub raw_unit: String,
pub raw_value: Decimal,
pub role: String,
#[serde(default)]
pub source_payload_id: Option<String>,
#[serde(default)]
pub start_date: Option<NaiveDate>,
pub taxonomy: String,
#[serde(default)]
pub ticker: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricLineageEnvelope {
pub data: Vec<MetricLineage>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricMapping {
pub concept: String,
pub priority: i64,
pub sign_multiplier: i64,
pub taxonomy: String,
#[serde(default)]
pub unit: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricRevision {
pub accession_number: String,
pub cik: i64,
#[serde(default)]
pub delta: Option<Decimal>,
pub end_date: NaiveDate,
pub entity_name: String,
#[serde(default)]
pub exchange: Option<String>,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
#[serde(default)]
pub fiscal_period: Option<String>,
#[serde(default)]
pub fiscal_year: Option<i64>,
#[serde(default)]
pub form: Option<String>,
pub kind: RevisionKind,
pub metric_key: String,
pub metric_label: String,
pub metric_unit: String,
pub metric_value_id: String,
pub period_kind: String,
#[serde(default)]
pub previous_value: Option<Decimal>,
pub raw_fact_id: String,
pub revision_rank: i64,
#[serde(default)]
pub split_ratio: Option<Decimal>,
pub standing: bool,
#[serde(default)]
pub start_date: Option<NaiveDate>,
#[serde(default)]
pub ticker: Option<String>,
pub value: Decimal,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricRevisionsEnvelope {
pub data: Vec<MetricRevision>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricStatementRef {
pub accession_number: String,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
#[serde(default)]
pub form: Option<String>,
pub kind: RevisionKind,
pub revision_rank: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricValue {
pub cik: i64,
pub confidence: Decimal,
pub end_date: NaiveDate,
pub entity_name: String,
#[serde(default)]
pub exchange: Option<String>,
#[serde(default)]
pub fiscal_period: Option<String>,
#[serde(default)]
pub fiscal_year: Option<i64>,
pub metric_key: String,
pub metric_label: String,
pub metric_value_id: String,
pub period_kind: String,
#[serde(default)]
pub read_from: Option<MetricStatementRef>,
#[serde(default)]
pub revised: Option<bool>,
#[serde(default)]
pub revision_count: Option<i64>,
#[serde(default)]
pub start_date: Option<NaiveDate>,
#[serde(default)]
pub statement: Option<String>,
#[serde(default)]
pub ticker: Option<String>,
pub unit: String,
pub value: Decimal,
pub value_kind: ValueKind,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct MetricValuesEnvelope {
pub data: Vec<MetricValue>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct PriceAction {
#[serde(default)]
pub evidence: Option<String>,
pub ex_date: NaiveDate,
pub kind: PriceActionKind,
#[serde(default)]
pub ratio: Option<Decimal>,
pub source: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct PriceLatest {
pub day: NaiveDate,
#[serde(default)]
pub last_sale_at: Option<DateTime<Utc>>,
#[serde(default)]
pub market_cap: Option<Decimal>,
pub price: Decimal,
#[serde(default)]
pub prior_day: Option<NaiveDate>,
#[serde(default)]
pub prior_price: Option<Decimal>,
#[serde(default)]
pub record_close: Option<Decimal>,
#[serde(default)]
pub record_day: Option<NaiveDate>,
#[serde(default)]
pub record_source: Option<String>,
#[serde(default)]
pub shares: Option<Decimal>,
#[serde(default)]
pub shares_as_of: Option<NaiveDate>,
pub source: String,
pub symbol: String,
pub updated_at: DateTime<Utc>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct PriceMark {
#[serde(default)]
pub agreement: Option<Decimal>,
pub close: Decimal,
pub day: NaiveDate,
pub sample: i64,
pub source: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Prices {
pub actions: Vec<PriceAction>,
pub adj_price: Vec<Decimal>,
pub cik: i64,
pub days: Vec<NaiveDate>,
pub entity_name: String,
pub from: NaiveDate,
#[serde(default)]
pub latest: Option<PriceLatest>,
pub market_cap: Vec<Option<Decimal>>,
pub marks: Vec<PriceMark>,
pub price: Vec<Decimal>,
pub source: Vec<PriceSource>,
pub ticker: String,
pub to: NaiveDate,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct PricesEnvelope {
pub data: Prices,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Problem {
pub code: ProblemCode,
pub detail: String,
pub request_id: String,
pub status: i64,
pub title: String,
#[serde(rename = "type")]
pub type_: String,
#[serde(rename = "violated-policies")]
#[serde(default)]
pub violated_policies: Option<Vec<LimitPolicy>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RawConcept {
pub cik: i64,
pub concept: String,
#[serde(default)]
pub earliest_end_date: Option<NaiveDate>,
pub entity_name: String,
pub exchange: String,
pub fact_count: i64,
#[serde(default)]
pub latest_end_date: Option<NaiveDate>,
pub taxonomy: String,
pub ticker: String,
pub unit: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RawConceptsEnvelope {
pub data: Vec<RawConcept>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Release {
pub checks: ReleaseChecks,
pub date: NaiveDate,
pub published_at: DateTime<Utc>,
pub stamp: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReleaseEnvelope {
pub data: Release,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ResponseMeta {
#[serde(default)]
pub as_of: Option<NaiveDate>,
#[serde(default)]
pub attribution: Option<Attribution>,
#[serde(default)]
pub collapse: Option<bool>,
#[serde(default)]
pub columns: Option<Vec<String>>,
#[serde(default)]
pub date: Option<NaiveDate>,
#[serde(default)]
pub dir: Option<SortDirection>,
#[serde(default)]
pub forms: Option<String>,
#[serde(default)]
pub keys: Option<Vec<String>>,
#[serde(default)]
pub kind: Option<TradeKind>,
#[serde(default)]
pub limit: Option<i64>,
#[serde(default)]
pub metric_key: Option<String>,
#[serde(default)]
pub offset: Option<i64>,
#[serde(default)]
pub period: Option<MetricPeriod>,
#[serde(default)]
pub query: Option<String>,
#[serde(default)]
pub release: Option<Release>,
pub request_id: String,
pub route: String,
pub schema: String,
#[serde(default)]
pub set_aside: Option<i64>,
#[serde(default)]
pub since: Option<NaiveDate>,
#[serde(default)]
pub sort: Option<String>,
#[serde(default)]
pub ticker: Option<String>,
#[serde(default)]
pub total: Option<i64>,
#[serde(default)]
pub universe: Option<i64>,
#[serde(rename = "where")]
#[serde(default)]
pub where_: Option<Vec<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ScreenEnvelope {
pub data: Vec<ScreenRow>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ScreenRow {
#[serde(default)]
pub annual_end_date: Option<NaiveDate>,
#[serde(default)]
pub assets: Option<Decimal>,
#[serde(default)]
pub capex_intensity: Option<Decimal>,
#[serde(default)]
pub capital_expenditures: Option<Decimal>,
#[serde(default)]
pub capital_returns: Option<Decimal>,
#[serde(default)]
pub capital_returns_to_fcf: Option<Decimal>,
#[serde(default)]
pub cash_and_equivalents: Option<Decimal>,
#[serde(default)]
pub cash_ratio: Option<Decimal>,
pub cik: i64,
#[serde(default)]
pub common_shares_outstanding: Option<Decimal>,
#[serde(default)]
pub coverage_state: Option<String>,
#[serde(default)]
pub current_assets: Option<Decimal>,
#[serde(default)]
pub current_liabilities: Option<Decimal>,
#[serde(default)]
pub current_ratio: Option<Decimal>,
#[serde(default)]
pub depreciation_and_amortization: Option<Decimal>,
#[serde(default)]
pub dividend_yield: Option<Decimal>,
#[serde(default)]
pub dividends_paid: Option<Decimal>,
#[serde(default)]
pub dividends_per_share: Option<Decimal>,
pub entity_name: String,
#[serde(default)]
pub eps_diluted: Option<Decimal>,
pub exchange: String,
#[serde(default)]
pub fcf_margin: Option<Decimal>,
#[serde(default)]
pub fcf_yield: Option<Decimal>,
#[serde(default)]
pub fcf_yield_ttm: Option<Decimal>,
#[serde(default)]
pub fiscal_year: Option<i64>,
#[serde(default)]
pub free_cash_flow: Option<Decimal>,
#[serde(default)]
pub free_cash_flow_ttm: Option<Decimal>,
#[serde(default)]
pub gross_margin: Option<Decimal>,
#[serde(default)]
pub gross_profit: Option<Decimal>,
#[serde(default)]
pub instant_end_date: Option<NaiveDate>,
#[serde(default)]
pub liabilities: Option<Decimal>,
#[serde(default)]
pub liabilities_to_equity: Option<Decimal>,
#[serde(default)]
pub market_cap: Option<Decimal>,
#[serde(default)]
pub net_income: Option<Decimal>,
#[serde(default)]
pub net_income_prior: Option<Decimal>,
#[serde(default)]
pub net_income_ttm: Option<Decimal>,
#[serde(default)]
pub net_income_yoy: Option<Decimal>,
#[serde(default)]
pub net_margin: Option<Decimal>,
#[serde(default)]
pub operating_cash_flow: Option<Decimal>,
#[serde(default)]
pub operating_cash_flow_ttm: Option<Decimal>,
#[serde(default)]
pub operating_income: Option<Decimal>,
#[serde(default)]
pub operating_margin: Option<Decimal>,
#[serde(default)]
pub payout_ratio: Option<Decimal>,
#[serde(default)]
pub pb: Option<Decimal>,
#[serde(default)]
pub pe: Option<Decimal>,
#[serde(default)]
pub pe_ttm: Option<Decimal>,
#[serde(default)]
pub price: Option<Decimal>,
#[serde(default)]
pub price_day: Option<NaiveDate>,
#[serde(default)]
pub prior_annual_end_date: Option<NaiveDate>,
#[serde(default)]
pub ps: Option<Decimal>,
#[serde(default)]
pub ps_ttm: Option<Decimal>,
#[serde(default)]
pub public_float: Option<Decimal>,
#[serde(default)]
pub public_float_end_date: Option<NaiveDate>,
#[serde(default)]
pub revenue: Option<Decimal>,
#[serde(default)]
pub revenue_prior: Option<Decimal>,
#[serde(default)]
pub revenue_ttm: Option<Decimal>,
#[serde(default)]
pub revenue_yoy: Option<Decimal>,
#[serde(default)]
pub roa: Option<Decimal>,
#[serde(default)]
pub roe: Option<Decimal>,
#[serde(default)]
pub sbc_intensity: Option<Decimal>,
#[serde(default)]
pub share_based_compensation: Option<Decimal>,
#[serde(default)]
pub share_repurchases: Option<Decimal>,
#[serde(default)]
pub shares_change: Option<Decimal>,
#[serde(default)]
pub shares_outstanding_end_date: Option<NaiveDate>,
#[serde(default)]
pub stockholders_equity: Option<Decimal>,
pub ticker: String,
#[serde(default)]
pub ttm_end_date: Option<NaiveDate>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecurityHolder {
pub accession_number: String,
pub amount: Decimal,
pub amount_type: String,
pub filed_at: NaiveDate,
pub holder_cik: i64,
pub holder_name: String,
#[serde(default)]
pub prior_amount: Option<Decimal>,
pub prior_known: bool,
#[serde(default)]
pub prior_value: Option<Decimal>,
pub value: Decimal,
#[serde(default)]
pub weight: Option<Decimal>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecurityHolders {
pub amount_held: Decimal,
pub cik: i64,
#[serde(default)]
pub closed: Option<i64>,
pub entity_name: String,
pub holders: i64,
#[serde(default)]
pub opened: Option<i64>,
pub period: NaiveDate,
#[serde(default)]
pub prior_amount_held: Option<Decimal>,
#[serde(default)]
pub prior_holders: Option<i64>,
#[serde(default)]
pub prior_period: Option<NaiveDate>,
pub rows: Vec<SecurityHolder>,
pub rows_total: i64,
pub ticker: String,
#[serde(default)]
pub updated_at: Option<DateTime<Utc>>,
pub value_held: Decimal,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecurityHoldersEnvelope {
pub data: SecurityHolders,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecurityProfile {
pub cik: i64,
pub company_coverage_state: String,
pub entity_name: String,
pub exchange: String,
pub filing_count: i64,
pub is_active: bool,
pub is_primary: bool,
#[serde(default)]
pub latest_filing_at: Option<NaiveDate>,
pub metric_value_count: i64,
#[serde(default)]
pub price: Option<PriceLatest>,
pub raw_fact_count: i64,
pub security_coverage_state: String,
pub security_id: String,
pub ticker: String,
pub ticker_normalized: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecurityProfileEnvelope {
pub data: SecurityProfile,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecuritySearchEnvelope {
pub data: Vec<SecuritySearchHit>,
pub meta: ResponseMeta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SecuritySearchHit {
pub cik: i64,
pub company_coverage_state: String,
pub entity_name: String,
pub exchange: String,
pub security_coverage_state: String,
pub ticker: String,
pub ticker_normalized: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SegmentAxis {
pub axis: Axis,
pub measures: Vec<SegmentMeasure>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SegmentMeasure {
pub concept: String,
pub measure: Measure,
pub members: Vec<SegmentMember>,
pub periods: Vec<SegmentPeriod>,
pub totals: Vec<Option<Decimal>>,
pub unit: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SegmentMember {
pub label: String,
pub member: String,
pub values: Vec<Option<Decimal>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SegmentPeriod {
pub accession_number: String,
#[serde(default)]
pub derived: Option<bool>,
pub end_date: NaiveDate,
#[serde(default)]
pub filed_at: Option<NaiveDate>,
pub fiscal_period: String,
pub fiscal_year: i64,
pub form: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Segments {
pub axes: Vec<SegmentAxis>,
pub cik: i64,
pub documents: i64,
pub entity_name: String,
pub period: SegmentsPeriod,
pub ticker: String,
#[serde(default)]
pub updated_at: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SegmentsEnvelope {
pub data: Segments,
pub meta: ResponseMeta,
}