Enum Interval

#[repr(i8)]
pub enum Interval {
    Day = 0,
    Minute = 1,
    ThreeMinute = 2,
    FiveMinute = 3,
    TenMinute = 4,
    FifteenMinute = 5,
    ThirtyMinute = 6,
    SixtyMinute = 7,
}

Interval types for historical data with dual serialization support

This enum represents time intervals for historical market data requests. Each variant corresponds to a specific time period for OHLCV candles.

Supported Intervals

• Day: Daily candles (most common for long-term analysis)
• Minute: 1-minute candles (highest resolution intraday)
• Multi-minute: 3, 5, 10, 15, 30, 60 minute candles (various intraday resolutions)

Data Availability

• Daily data: Several years of history available
• Intraday data: Limited to recent periods (varies by broker)
• Higher frequency: More data points but faster rate limit consumption

Rate Limiting Considerations

Higher frequency intervals generate more data points and may consume rate limits faster. Consider using appropriate intervals for your use case:

• Backtesting: Daily or hourly data
• Real-time monitoring: 1-5 minute data
• Pattern analysis: 15-30 minute data

Integer Mapping

For legacy compatibility, intervals map to integers:

• Day = 0
• Minute = 1
• ThreeMinute = 2
• FiveMinute = 3
• TenMinute = 4
• FifteenMinute = 5
• ThirtyMinute = 6
• SixtyMinute = 7

Examples

use kiteconnect_async_wasm::models::common::Interval;

// Different ways to create intervals
let daily = Interval::Day;
let intraday = Interval::FiveMinute;

// Convert to string for display
println!("Daily interval: {}", daily);      // "day"
println!("Intraday: {}", intraday);         // "5minute"

// Check if interval is intraday (less than a day)
assert_ne!(daily.to_string(), "minute");
assert_eq!(intraday.to_string(), "5minute");

Variants

Day = 0

Daily interval (1 day candles)

Most commonly used for long-term analysis, backtesting, and trend identification. Provides good data coverage with minimal API rate limit impact.

Minute = 1

1-minute interval (highest resolution)

Highest available resolution for intraday analysis. Useful for:

• Scalping strategies
• Real-time monitoring
• High-frequency pattern analysis

Note: Consumes rate limits quickly due to large data volumes.

ThreeMinute = 2

3-minute interval

Good balance between resolution and data volume for short-term strategies.

FiveMinute = 3

5-minute interval

Popular choice for intraday trading strategies. Provides good detail while maintaining manageable data volumes.

TenMinute = 4

10-minute interval

Suitable for medium-term intraday analysis with reduced noise.

FifteenMinute = 5

15-minute interval

Common choice for swing trading and pattern recognition. Good balance of detail and broader market perspective.

ThirtyMinute = 6

30-minute interval

Used for identifying medium-term trends within trading sessions. Filters out short-term noise while maintaining intraday perspective.

SixtyMinute = 7

60-minute (1-hour) interval

Bridge between intraday and daily analysis. Useful for:

• Multi-session analysis
• Identifying major support/resistance levels
• Trend confirmation

Implementations

impl Interval

pub fn as_i8(self) -> i8

Get the integer representation of the interval

pub fn from_i8(value: i8) -> Option<Self>

Create an interval from its integer representation

pub fn all() -> Vec<Self>

All available intervals

Trait Implementations

impl Clone for Interval

fn clone(&self) -> Interval

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Interval

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Interval

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

Formats the value using the given formatter.

impl Hash for Interval

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 PartialEq for Interval

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Interval

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Interval

impl Eq for Interval

impl StructuralPartialEq for Interval