Enum CandleInterval 

pub enum CandleInterval {
    Sec1,
    Sec5,
    Sec15,
    Sec30,
    Min1,
    Min3,
    Min5,
    Min15,
    Min30,
    Hour1,
    Hour2,
    Hour4,
    Hour6,
    Hour8,
    Hour12,
    Day1,
    Day3,
    Week1,
    Month1,
}

Candle interval/resolution, shared across every venue that produces candles.

This is the venue-agnostic union of all supported candle resolutions — it is deliberately not gated to any one exchange’s capabilities. Per-venue support rules (e.g. Hyperliquid rejecting Sec1/Hour6) live in the exchange layer, not on this enum (separation of concerns). Because the enum is a union, each venue’s interval guard must be re-reviewed whenever a variant is added.

String form

as_str is the single source of truth for every string representation: Display, Serialize, FromStr and Deserialize all delegate to it (or its inverse), so there is exactly one place mapping variant↔string. The strings follow Binance’s kline interval convention and are case-sensitive — note Month1 → "1M" (uppercase) vs Min1 → "1m". The union is a superset of any one venue’s menu: Sec5/Sec15/Sec30 have no Binance kline equivalent, so a string round-trip is not proof a venue serves it.

Ordering

Variants are declared in ascending duration order. Ord/PartialOrd exist only as a compile requirement (the type embeds in Candles, which must stay Ord to preserve the derived Ord on Subscription); the chronological declaration order makes the derived order at least sensible. Nothing currently sorts intervals semantically.

Variants

Sec1

1 second

Sec5

5 seconds

Sec15

15 seconds

Sec30

30 seconds

Min1

1 minute

Min3

3 minutes

Min5

5 minutes

Min15

15 minutes

Min30

30 minutes

Hour1

1 hour

Hour2

2 hours

Hour4

4 hours

Hour6

6 hours

Hour8

8 hours

Hour12

12 hours

Day1

1 day

Day3

3 days

Week1

1 week

Month1

1 month

Implementations

impl CandleInterval

pub const ALL: [CandleInterval; 19]

Every CandleInterval variant, in ascending-duration declaration order.

Lets variant-exhaustive tests (round-trip, channel-suffix drift guards) iterate without hand-listing the variants.

When adding a CandleInterval variant, add it here too: the length literal and the candle_interval_all_covers_every_variant_in_ascending_order test pin ALL’s length to the variant count, but full coverage is not compile-enforced — the exhaustive matches elsewhere are the compile gate.

pub fn as_str(&self) -> &'static str

The exchange string form of this interval (e.g. "1m", "6h", "1M").

The single source of truth for all string representations — Display, Serialize, FromStr and Deserialize all key off this. Case-sensitive: Month1 → "1M", every other variant lowercase.

pub fn to_step(self) -> IntervalStep

Map this interval to the shared IntervalStep used to compute a candle’s exclusive close_time boundary via close_time_from_open. All intervals are fixed-length except 1M, which is a calendar month.

Trait Implementations

impl Clone for CandleInterval

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CandleInterval

impl Debug for CandleInterval

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CandleInterval

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CandleInterval

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

Formats the value using the given formatter.

impl Eq for CandleInterval

impl FromStr for CandleInterval

fn from_str(s: &str) -> Result<Self, Self::Err>

The inverse of CandleInterval::as_str — case-sensitive ("1M" is the only uppercase form). Keeps variant↔string mapping in exactly one place.

type Err = ParseCandleIntervalError

The associated error which can be returned from parsing.

impl Hash for CandleInterval

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for CandleInterval

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for CandleInterval

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for CandleInterval

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for CandleInterval

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CandleInterval