Struct LseCatalogEntry 

pub struct LseCatalogEntry {

    pub dataset: SmolStr,
    pub symbol: SmolStr,
    pub name: String,
    pub ticks: u64,
    pub first_tick: String,
    pub last_tick: String,
    pub years: f64,
    pub last_value: f64,
    pub change_pct: f64,
    pub change_1y: f64,
    pub unit: SmolStr,
    pub source: SmolStr,
    pub category: SmolStr,
    pub frequency: SmolStr,
    pub country: SmolStr,
    pub country_name: String,
    pub live: u8,
}

One catalog record, as the vault serves it.

All seventeen fields were present and non-null on every one of the 22,966 entries measured, so none is optional. The six descriptive fields nonetheless carry #[serde(default)]: they are routinely the empty string already (unit on 7,805 entries, source on 8,057), so an absent field and an empty one mean the same thing here and tolerating absence hides nothing.

Unknown fields are ignored, so a field the provider adds does not break decoding.

Fields

dataset: SmolStr

Dataset name as the catalog spells it ("crypto", "economics", …).

Kept as the provider’s string rather than as an LseDataset, which models price datasets only. Use price_dataset to resolve one where it exists.

symbol: SmolStr

Symbol within the dataset ("BTC/USD", "chlinfind", …).

Unique only together with dataset, not on its own.

name: String

Human-readable series name ("Bitcoin").

ticks: u64

Observation count the provider reports for the series.

u64, not u32, and that is not defensive. The largest measured value is 4,145,394,353 — 96.5% of u32::MAX — on a live crypto tape that keeps growing, so a 32-bit count would overflow within months of the measurement.

first_tick: String

First observation, spelled 2017-08-17 04:00:28.322000 (UTC, no zone marker, the fractional part optional). Parse with first_tick_time.

last_tick: String

Last observation, spelled as first_tick is. Parse with last_tick_time.

⚠️ This is a catalog summary statistic and it lags the live tape — measured six hours behind on a continuously trading crypto symbol. It describes the catalog’s own refresh, not feed liveness, and must not be used as a staleness check on a stream.

years: f64

Span of the series in years, as the provider computes it.

last_value: f64

Most recent value, in whatever unit the series is quoted in.

A display statistic spanning nine orders of magnitude across the catalog (-20,458,587 to 74,226,775,000), carried as f64 because that is the precision the provider serves it at. Never an execution input — fetch the series itself for that.

change_pct: f64

Most recent change, percent.

change_1y: f64

Change over the trailing year, percent.

unit: SmolStr

Unit of quotation ("percent", "USD Million", "index", …); empty for price datasets.

source: SmolStr

Upstream publisher. Populated only for economics, and not a clean vocabulary — two spellings of one source were measured ("World Bank" 728 entries, "Worldbank" 344).

category: SmolStr

Reference category ("Government bond yield", "Credit index", …); empty for price datasets. Half of the class rule.

frequency: SmolStr

Publication frequency as the provider labels it; empty for price datasets. The other half of the class rule.

⚠️ A dirty label that does not predict observed spacing — see the module documentation before relying on it.

country: SmolStr

Country code.

⚠️ The vault spells the United Kingdom GB here, while the data-api host’s /bond-yields endpoint spells the same country UK — the only divergence among the 34 codes, and neither host errors on the other’s spelling. Normalise before crossing hosts.

country_name: String

Country name ("United States").

live: u8

Whether the series streams: 1 for a live price dataset, 0 otherwise.

Kept as the provider’s integer rather than a bool so a third value would survive decoding instead of being coerced. Read it through is_live. Every one of the 15,537 reference entries measured carries 0.

Implementations

impl LseCatalogEntry

pub fn class(&self) -> LseDatasetClass

Classifies the entry as a price dataset or a reference series.

Uses the provider’s own frequency/category pair; see the module documentation for the rule and the measurement behind it. An entry populating exactly one of the two — which no measured entry does — is reported as Reference, since a populated category is what distinguishes a non-instrument.

pub fn price_dataset(&self) -> Option<LseDataset>

Resolves dataset to an LseDataset, where one exists.

None does not mean “reference”

It means “no LseDataset variant”, and the catalog has two sources of that:

• every reference family, which is LseDataset::from_catalog_str’s documented contract rather than a failure — those are not instruments and have no variant; and
• options, which is a price dataset and still has no variant. Measured: of 7,429 price-classified entries, 4,243 resolve and the remaining 3,186 are all options.

So pair this with class rather than reading None as a classification. An entry with LseDatasetClass::Price and None here is an option contract.

pub fn is_live(&self) -> bool

Whether the series streams live.

pub fn first_tick_time(&self) -> Result<DateTime<Utc>, LseError>

Parses first_tick as an instant.

Errors

Returns LseError::Deserialize if the value is not in the provider’s timestamp spelling, naming the field so the caller can tell which of the two failed.

pub fn last_tick_time(&self) -> Result<DateTime<Utc>, LseError>

Parses last_tick as an instant.

⚠️ Lags the live tape — see the field’s own documentation.

Errors

Returns LseError::Deserialize if the value is not in the provider’s timestamp spelling, naming the field so the caller can tell which of the two failed.

Trait Implementations

impl Clone for LseCatalogEntry

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LseCatalogEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LseCatalogEntry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LseCatalogEntry

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LseCatalogEntry